react-native-vroom-chart 0.1.0

package/cpp/_core_src/rsi_pane.cpp

@@ -0,0 +1,167 @@
+#include "rsi_pane.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkFont.h"
+#include "include/core/SkFontTypes.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkPath.h"
+#include "include/core/SkPathBuilder.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkTypeface.h"
+#include "include/effects/SkDashPathEffect.h"
+#pragma clang diagnostic pop
+
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+
+#include "chart.h"
+#include "fonts.h"
+#include "theme.h"
+#include "viewport.h"
+
+namespace vroom::rsi_pane {
+
+namespace {
+constexpr SkColor kRsiLine = 0xff8957e5;    // violet RSI line (themable later)
+constexpr SkColor kRsiMaLine = 0xffd29922;  // amber RSI moving-average trendline
+constexpr SkColor kRefLine = 0xff30363d;    // band reference lines
+constexpr SkColor kDivider = 0xff21262d;    // pane separator
+constexpr SkScalar kDash[2] = {3.f, 3.f};
+}  // namespace
+
+void draw(SkCanvas* canvas,
+          const VroomChart& chart,
+          const Layout& lay,
+          const ::VroomCandle* visible,
+          std::size_t n,
+          const double* rsi_visible,
+          const double* rsi_ma_visible,
+          int64_t window_ms,
+          int64_t visible_start_ms,
+          int64_t candle_duration_ms,
+          float candle_right,
+          float pane_top,
+          float pane_bottom) {
+    if (!canvas || n == 0 || candle_right <= 0.f) return;
+    const float band_h = pane_bottom - pane_top;
+    if (band_h <= 0.f) return;
+
+    auto y_for = [&](double v) -> float {
+        return pane_bottom - static_cast<float>(v / 100.0) * band_h;
+    };
+
+    // Mask the band with the background so candles/volume that overflow below
+    // the (shortened) price pane don't show through behind the RSI. The y-axis
+    // strip to the right is already masked full-height by draw_chart.
+    SkPaint bg;
+    bg.setColor(chart.theme.colors[VROOM_COLOR_BACKGROUND]);
+    canvas->drawRect(SkRect::MakeLTRB(0.f, pane_top, candle_right, pane_bottom),
+                     bg);
+
+    // Pane separator (top edge).
+    SkPaint divider;
+    divider.setColor(kDivider);
+    divider.setStrokeWidth(1.f);
+    canvas->drawLine(0.f, pane_top, candle_right, pane_top, divider);
+
+    // Keep the line + reference lines inside the pane / candle area.
+    canvas->save();
+    canvas->clipRect(SkRect::MakeLTRB(0.f, pane_top, candle_right, pane_bottom));
+
+    // Configurable band reference lines (overbought / oversold).
+    SkPaint ref;
+    ref.setAntiAlias(true);
+    ref.setColor(kRefLine);
+    ref.setStrokeWidth(1.f);
+    ref.setPathEffect(SkDashPathEffect::Make(kDash, 0.f));
+    const float y_upper = y_for(chart.rsi_upper);
+    const float y_lower = y_for(chart.rsi_lower);
+    canvas->drawLine(0.f, y_upper, candle_right, y_upper, ref);
+    canvas->drawLine(0.f, y_lower, candle_right, y_lower, ref);
+
+    // 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) {
+        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;
+            }
+        }
+        SkPaint line;
+        line.setAntiAlias(true);
+        line.setColor(color);
+        line.setStyle(SkPaint::kStroke_Style);
+        line.setStrokeWidth(1.5f);
+        canvas->drawPath(path.detach(), line);
+    };
+    stroke_series(rsi_visible, kRsiLine);
+    stroke_series(rsi_ma_visible, kRsiMaLine);  // trendline on top
+
+    // Caption, top-left of the pane.
+    auto tf = vroom::axis_typeface();
+    if (tf) {
+        SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
+        font.setSubpixel(true);
+        font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+
+        char caption[24];
+        std::snprintf(caption, sizeof(caption), "RSI %d", chart.rsi_period);
+        SkRect cb;
+        font.measureText(caption, std::strlen(caption), SkTextEncoding::kUTF8,
+                         &cb);
+        SkPaint cap_paint;
+        cap_paint.setAntiAlias(true);
+        cap_paint.setColor(chart.theme.colors[VROOM_COLOR_AXIS_TEXT]);
+        canvas->drawString(caption, 6.f, pane_top + 4.f - cb.fTop, font,
+                           cap_paint);
+    }
+    canvas->restore();
+
+    // 70 / 30 labels in the y-axis strip (drawn after the clip; the strip's
+    // background was already masked by draw_chart before this call).
+    if (tf) {
+        SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
+        font.setSubpixel(true);
+        font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+        SkPaint text_paint;
+        text_paint.setAntiAlias(true);
+        text_paint.setColor(chart.theme.colors[VROOM_COLOR_AXIS_TEXT]);
+
+        const float axis_center_x = lay.width_px - lay.y_axis_width_px * 0.5f;
+        auto label = [&](const char* s, float y) {
+            SkRect tb;
+            const float tw = font.measureText(s, std::strlen(s),
+                                              SkTextEncoding::kUTF8, &tb);
+            const float text_x = axis_center_x - tw * 0.5f;
+            const float baseline_y = y - (tb.fTop + tb.fBottom) * 0.5f;
+            canvas->drawString(s, text_x, baseline_y, font, text_paint);
+        };
+        char ub[8];
+        char lb[8];
+        std::snprintf(ub, sizeof(ub), "%.0f", chart.rsi_upper);
+        std::snprintf(lb, sizeof(lb), "%.0f", chart.rsi_lower);
+        label(ub, y_upper);
+        label(lb, y_lower);
+    }
+}
+
+}  // namespace vroom::rsi_pane

package/cpp/_core_src/rsi_pane.h

@@ -0,0 +1,39 @@
+// RSI indicator pane — draws the RSI line, 70/30 reference lines, axis labels,
+// and a caption in the band below the candles. Its own module alongside
+// candles / volume / price_indicator so the chart orchestrator stays thin.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+#include "vroom/vroom_chart.h"  // ::VroomCandle
+
+class SkCanvas;
+
+namespace vroom {
+struct Layout;
+}  // namespace vroom
+
+struct VroomChart;
+
+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.
+void draw(SkCanvas* canvas,
+          const VroomChart& chart,
+          const Layout& lay,
+          const ::VroomCandle* visible,
+          std::size_t n,
+          const double* rsi_visible,
+          const double* rsi_ma_visible,
+          int64_t window_ms,
+          int64_t visible_start_ms,
+          int64_t candle_duration_ms,
+          float candle_right,
+          float pane_top,
+          float pane_bottom);
+
+}  // namespace vroom::rsi_pane

package/cpp/_core_src/theme.cpp

@@ -0,0 +1,41 @@
+#include "theme.h"
+
+namespace vroom {
+
+namespace {
+
+// GitHub-dark palette.
+constexpr uint32_t kDefaultColors[VROOM_COLOR_COUNT_] = {
+    0xff0d1117,  // BACKGROUND
+    0xff26a69a,  // BULL
+    0xffef5350,  // BEAR
+    0xffaaaaaa,  // WICK
+    0xff1a1e24,  // GRID — ~20% darker than the crosshair so it recedes
+    0xffc9d1d9,  // AXIS_TEXT
+    0xff303741,  // CROSSHAIR — grid tone lightened ~44%; reads above GRID
+    0xff161b22,  // TOOLTIP_BG
+    0xffc9d1d9,  // TOOLTIP_TEXT
+    0xff3e4855,  // CROSSHAIR_TARGET — CROSSHAIR lightened 30% (prior derived ring)
+};
+
+constexpr float kDefaultFloats[VROOM_FLOAT_COUNT_] = {
+    0.68f,  // CANDLE_WIDTH_RATIO — body fills 68% of slot, 32% gap
+    1.0f,   // WICK_WIDTH_PX
+    6.f,    // RIGHT_PADDING_PX — small gutter between candles and y-axis
+    11.f,   // AXIS_FONT_SIZE_PX
+    0.18f,  // Y_AXIS_WIDTH_RATIO — fallback before font is loaded
+    22.f,   // X_AXIS_HEIGHT_PX — bottom strip for time labels
+    0.5f,   // VOLUME_OPACITY — candle color at 50% transparency
+    0.20f,  // INDICATOR_HEIGHT_FRAC — below-chart indicator pane = 20% of height
+};
+
+}  // namespace
+
+Theme default_theme() {
+    Theme t;
+    for (int i = 0; i < VROOM_COLOR_COUNT_; ++i) t.colors[i] = kDefaultColors[i];
+    for (int i = 0; i < VROOM_FLOAT_COUNT_; ++i) t.floats[i] = kDefaultFloats[i];
+    return t;
+}
+
+}  // namespace vroom

package/cpp/_core_src/theme.h

@@ -0,0 +1,23 @@
+// Theme — colors and float-typed style parameters for a single chart.
+//
+// Layout: indexed arrays keyed by the public C-facade enums (VroomColorKey,
+// VroomFloatKey) so we can stay ABI-stable while adding new keys. Wrapped in
+// a struct so future expansion (booleans for visibility toggles, strings for
+// label formats) lands as new sub-arrays without churning every field access.
+
+#pragma once
+
+#include "vroom/vroom_chart.h"
+
+namespace vroom {
+
+struct Theme {
+    uint32_t colors[VROOM_COLOR_COUNT_]{};
+    float    floats[VROOM_FLOAT_COUNT_]{};
+};
+
+// Returns a Theme pre-filled with the default dark palette + sensible
+// layout defaults. Used by `VroomChart`'s constructor.
+Theme default_theme();
+
+}  // namespace vroom

package/cpp/_core_src/ticks.cpp

@@ -0,0 +1,49 @@
+#include "ticks.h"
+
+#include <algorithm>
+#include <cmath>
+
+namespace vroom {
+
+int64_t pick_time_interval(int64_t window_ms, float candle_area_w) {
+    static constexpr int64_t kIntervals[] = {
+        60'000LL,                // 1m
+        5 * 60'000LL,            // 5m
+        15 * 60'000LL,           // 15m
+        30 * 60'000LL,           // 30m
+        60 * 60'000LL,           // 1h
+        2 * 60 * 60'000LL,       // 2h
+        4 * 60 * 60'000LL,       // 4h
+        6 * 60 * 60'000LL,       // 6h
+        12 * 60 * 60'000LL,      // 12h
+        24 * 60 * 60'000LL,      // 1d
+        2 * 24 * 60 * 60'000LL,  // 2d
+        7 * 24 * 60 * 60'000LL,  // 1w
+    };
+    if (window_ms <= 0 || candle_area_w <= 0.f) return kIntervals[0];
+    const double ms_per_px =
+        static_cast<double>(window_ms) / candle_area_w;
+    for (int64_t i : kIntervals) {
+        if (static_cast<double>(i) / ms_per_px >= kXLabelMinSpacing) {
+            return i;
+        }
+    }
+    return kIntervals[sizeof(kIntervals) / sizeof(kIntervals[0]) - 1];
+}
+
+double pick_price_interval(double range, float candle_area_h) {
+    if (range <= 0.0 || candle_area_h <= 0.f) return 1.0;
+    const int target_count =
+        std::max(2, static_cast<int>(candle_area_h / kYLabelTargetSpacing));
+    const double rough = range / target_count;
+    const double magnitude = std::pow(10.0, std::floor(std::log10(rough)));
+    const double normalized = rough / magnitude;
+    double nice;
+    if (normalized < 1.5) nice = 1.0;
+    else if (normalized < 3.5) nice = 2.0;
+    else if (normalized < 7.5) nice = 5.0;
+    else nice = 10.0;
+    return nice * magnitude;
+}
+
+}  // namespace vroom

package/cpp/_core_src/ticks.h

@@ -0,0 +1,30 @@
+// Tick algorithms — pick a label interval based on current scale so labels
+// land on canonical boundaries with reasonable spacing.
+//
+// Pure functions, no state. Used by the label subsystem; safe for future
+// indicators that need their own axis grids to reuse.
+
+#pragma once
+
+#include <cstdint>
+
+namespace vroom {
+
+// Minimum spacing between adjacent x-axis labels in pixels. Smaller → more
+// labels visible at every zoom level; larger → sparser.
+inline constexpr float kXLabelMinSpacing = 50.f;
+
+// Target spacing for y-axis labels — used to derive a target count.
+inline constexpr float kYLabelTargetSpacing = 55.f;
+
+// Selects the smallest time interval whose pixel-spacing meets the minimum.
+// Returns milliseconds. Hierarchy: 1m → 5m → 15m → 30m → 1h → 2h → 4h → 6h →
+// 12h → 1d → 2d → 1w.
+int64_t pick_time_interval(int64_t window_ms, float candle_area_w);
+
+// "Nice number" tick selection for the y-axis: snaps to 1, 2, or 5 × 10ⁿ
+// based on the price range and target spacing. Returns the price interval
+// in the same units as the data (e.g. dollars).
+double pick_price_interval(double range, float candle_area_h);
+
+}  // namespace vroom

package/cpp/_core_src/viewport.cpp

@@ -0,0 +1,141 @@
+#include "viewport.h"
+
+#include <algorithm>
+#include <limits>
+
+namespace vroom {
+
+float candle_body_width(const Layout& layout,
+                        int64_t window_ms,
+                        int64_t candle_duration_ms) {
+    if (window_ms <= 0 || candle_duration_ms <= 0) return 0.f;
+    const float usable =
+        layout.width_px - layout.y_axis_width_px - layout.right_padding_px;
+    const double slot = static_cast<double>(usable) *
+        (static_cast<double>(candle_duration_ms) /
+         static_cast<double>(window_ms));
+    return static_cast<float>(slot * layout.candle_width_ratio);
+}
+
+float candle_center_x(const Layout& layout,
+                      int64_t time_ms,
+                      int64_t candle_duration_ms,
+                      int64_t visible_start_ms,
+                      int64_t window_ms) {
+    if (window_ms <= 0) return 0.f;
+    const float usable =
+        layout.width_px - layout.y_axis_width_px - layout.right_padding_px;
+    const double center_time =
+        static_cast<double>(time_ms) +
+        static_cast<double>(candle_duration_ms) * 0.5;
+    const double frac =
+        (center_time - static_cast<double>(visible_start_ms)) /
+        static_cast<double>(window_ms);
+    return static_cast<float>(static_cast<double>(usable) * frac);
+}
+
+size_t snap_index_to_candle(const Layout& layout,
+                            const ::VroomCandle* candles,
+                            size_t count,
+                            int64_t candle_duration_ms,
+                            int64_t visible_start_ms,
+                            int64_t window_ms,
+                            float x_px) {
+    const float usable =
+        layout.width_px - layout.y_axis_width_px - layout.right_padding_px;
+    if (usable <= 0.f) return 0;
+
+    // Pixel x -> the period start time of the candle that would sit there.
+    const double target_center =
+        static_cast<double>(visible_start_ms) +
+        (static_cast<double>(x_px) / static_cast<double>(usable)) *
+            static_cast<double>(window_ms);
+    const int64_t key =
+        static_cast<int64_t>(target_center) - candle_duration_ms / 2;
+
+    // First candle with time_ms >= key, then pick whichever of it / its
+    // predecessor is closer in time.
+    auto* it = std::lower_bound(
+        candles, candles + count, key,
+        [](const ::VroomCandle& c, int64_t t) { return c.time_ms < t; });
+    if (it == candles) return 0;
+    if (it == candles + count) return count - 1;
+    const int64_t hi = it->time_ms;
+    const int64_t lo = (it - 1)->time_ms;
+    return (hi - key < key - lo) ? static_cast<size_t>(it - candles)
+                                 : static_cast<size_t>(it - 1 - candles);
+}
+
+float snap_x_to_candle(const Layout& layout,
+                       const ::VroomCandle* candles,
+                       size_t count,
+                       int64_t candle_duration_ms,
+                       int64_t visible_start_ms,
+                       int64_t window_ms,
+                       float x_px) {
+    if (count == 0 || window_ms <= 0) return x_px;
+
+    const float usable =
+        layout.width_px - layout.y_axis_width_px - layout.right_padding_px;
+    if (usable <= 0.f) return x_px;
+
+    const size_t idx = snap_index_to_candle(
+        layout, candles, count, candle_duration_ms, visible_start_ms,
+        window_ms, x_px);
+    return candle_center_x(layout, candles[idx].time_ms, candle_duration_ms,
+                           visible_start_ms, window_ms);
+}
+
+IndexRange visible_indices(const ::VroomCandle* candles,
+                           size_t count,
+                           int64_t start_ms,
+                           int64_t end_ms) {
+    if (count == 0) return {0, 0};
+    if (start_ms == 0 && end_ms == 0) return {0, count};
+
+    // first index with time_ms >= start_ms
+    auto* first = std::lower_bound(
+        candles, candles + count, start_ms,
+        [](const ::VroomCandle& c, int64_t t) { return c.time_ms < t; });
+    // first index with time_ms > end_ms
+    auto* last = std::upper_bound(
+        candles, candles + count, end_ms,
+        [](int64_t t, const ::VroomCandle& c) { return t < c.time_ms; });
+    return {
+        static_cast<size_t>(first - candles),
+        static_cast<size_t>(last - candles),
+    };
+}
+
+PriceBounds price_bounds(const ::VroomCandle* candles, size_t count) {
+    PriceBounds b{
+        std::numeric_limits<double>::infinity(),
+        -std::numeric_limits<double>::infinity(),
+    };
+    for (size_t i = 0; i < count; ++i) {
+        b.min = std::min(b.min, candles[i].low);
+        b.max = std::max(b.max, candles[i].high);
+    }
+    if (count == 0) {
+        b.min = 0.0;
+        b.max = 1.0;
+    }
+    return b;
+}
+
+float price_to_y(const Layout& layout,
+                 const PriceBounds& bounds,
+                 double price) {
+    // The candle drawing area is the full height minus the x-axis strip and
+    // any below-chart indicator pane.
+    const float candle_area_h = price_pane_bottom(layout);
+    const float top = candle_area_h * layout.top_padding_frac;
+    const float bot = candle_area_h * (1.f - layout.bottom_padding_frac);
+    const float draw_h = bot - top;
+    const double range = bounds.max - bounds.min;
+    if (range <= 0.0) return (top + bot) * 0.5f;
+    const double t = (price - bounds.min) / range;  // 0..1, 0 at min
+    return bot - static_cast<float>(t) * draw_h;    // invert: high price → low y
+}
+
+}  // namespace vroom

package/cpp/_core_src/viewport.h

@@ -0,0 +1,100 @@
+// Viewport math — pure functions, no Skia, no state.
+// Translates between candle indices, time, price, and screen pixels.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+#include "vroom/vroom_chart.h"
+
+namespace vroom {
+
+struct Layout {
+    float width_px;             // total chart width
+    float height_px;            // total chart height
+    float y_axis_width_px;      // reserved on the right for price labels
+    float x_axis_height_px;     // reserved at the bottom for time labels
+    float right_padding_px;     // small gutter between candles and y-axis
+    float candle_width_ratio;   // 0..1 of slot stride taken by the body
+    float top_padding_frac;     // fraction of candle area; keeps prices off edges
+    float bottom_padding_frac;
+    float indicator_area_h;     // height reserved for below-chart indicator panes
+};
+
+// Bottom of the price (candle) pane = top of the indicator band. Shrinks when
+// an indicator pane is present so candles, volume, and price labels reflow.
+inline float price_pane_bottom(const Layout& l) {
+    return l.height_px - l.x_axis_height_px - l.indicator_area_h;
+}
+
+// Top of the bottom time-axis strip. Stays anchored regardless of any indicator
+// band (the strip is always the bottom x_axis_height_px of the chart).
+inline float x_axis_top(const Layout& l) {
+    return l.height_px - l.x_axis_height_px;
+}
+
+struct PriceBounds {
+    double min;
+    double max;
+};
+
+// Half-open [start, end) range of candle indices.
+struct IndexRange {
+    size_t start;
+    size_t end;
+};
+
+// 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).
+IndexRange visible_indices(const ::VroomCandle* candles,
+                           size_t count,
+                           int64_t start_ms,
+                           int64_t end_ms);
+
+// Width of one candle body in pixels, computed from the time slot a single
+// candle occupies (candle_duration_ms / window_ms × candle area).
+float candle_body_width(const Layout& layout,
+                        int64_t window_ms,
+                        int64_t candle_duration_ms);
+
+// Center-x of a candle whose period starts at time_ms and lasts
+// candle_duration_ms, given the current visible time window.
+float candle_center_x(const Layout& layout,
+                      int64_t time_ms,
+                      int64_t candle_duration_ms,
+                      int64_t visible_start_ms,
+                      int64_t window_ms);
+
+// Index of the candle whose center is nearest pixel x_px, searching
+// [candles, candles+count). Clamps to the first/last candle. This is the
+// integer counterpart of snap_x_to_candle — both share the same nearest-candle
+// math. Precondition: count > 0 and window_ms > 0 (callers guard).
+size_t snap_index_to_candle(const Layout& layout,
+                            const ::VroomCandle* candles,
+                            size_t count,
+                            int64_t candle_duration_ms,
+                            int64_t visible_start_ms,
+                            int64_t window_ms,
+                            float x_px);
+
+// On-screen x of the candle whose center is nearest pixel x_px, searching
+// [candles, candles+count). Clamps to the first/last candle. Returns x_px
+// unchanged when there are no candles or the window is degenerate. Used to snap
+// the crosshair to candles.
+float snap_x_to_candle(const Layout& layout,
+                       const ::VroomCandle* candles,
+                       size_t count,
+                       int64_t candle_duration_ms,
+                       int64_t visible_start_ms,
+                       int64_t window_ms,
+                       float x_px);
+
+// Min/max of (low..high) across the given range.
+PriceBounds price_bounds(const ::VroomCandle* candles, size_t count);
+
+// Map a price to y in pixels. y=0 is top of the chart.
+float price_to_y(const Layout& layout, const PriceBounds& bounds, double price);
+
+}  // namespace vroom

package/cpp/_core_src/volume.cpp

@@ -0,0 +1,70 @@
+#include "volume.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkRect.h"
+#pragma clang diagnostic pop
+
+#include <algorithm>
+
+#include "theme.h"
+#include "viewport.h"
+
+namespace vroom::volume {
+
+namespace {
+constexpr float kVolumeFrac = 0.20f;  // tallest bar = this fraction of the area
+}  // namespace
+
+void draw(SkCanvas* canvas,
+          const ::VroomCandle* visible,
+          std::size_t n,
+          const Layout& lay,
+          const Theme& theme,
+          int64_t window_ms,
+          int64_t visible_start_ms,
+          int64_t candle_duration_ms) {
+    if (!canvas || n == 0) return;
+
+    // Auto-fit bar heights to the loudest volume currently in view.
+    double max_vol = 0.0;
+    for (std::size_t i = 0; i < n; ++i) max_vol = std::max(max_vol, visible[i].volume);
+    if (max_vol <= 0.0) return;
+
+    const float candle_area_h = vroom::price_pane_bottom(lay);
+    const float region_h = candle_area_h * kVolumeFrac;
+
+    const float body_w = vroom::candle_body_width(
+        lay, window_ms, candle_duration_ms);
+    const float half_body = body_w * 0.5f;
+
+    const float opacity = theme.floats[VROOM_FLOAT_VOLUME_OPACITY];
+    SkPaint bull_paint;
+    bull_paint.setAntiAlias(true);
+    bull_paint.setColor(theme.colors[VROOM_COLOR_BULL]);
+    bull_paint.setAlphaf(opacity);
+
+    SkPaint bear_paint;
+    bear_paint.setAntiAlias(true);
+    bear_paint.setColor(theme.colors[VROOM_COLOR_BEAR]);
+    bear_paint.setAlphaf(opacity);
+
+    for (std::size_t i = 0; i < n; ++i) {
+        const auto& c = visible[i];
+        if (c.volume <= 0.0) continue;
+        const bool bull = c.close >= c.open;
+
+        const float cx = vroom::candle_center_x(
+            lay, c.time_ms, candle_duration_ms,
+            visible_start_ms, window_ms);
+        const float h = std::max(
+            1.f, static_cast<float>(c.volume / max_vol) * region_h);
+        canvas->drawRect(
+            SkRect::MakeXYWH(cx - half_body, candle_area_h - h, body_w, h),
+            bull ? bull_paint : bear_paint);
+    }
+}
+
+}  // namespace vroom::volume