Struct GpuStreamingChart 

pub struct GpuStreamingChart { /* private fields */ }

GPU-accelerated streaming chart for high-performance live data visualization.

Combines StreamingChart functionality with GPU-accelerated renderers for efficient rendering of large datasets. The GPU path is automatically used when series exceed GPU_RENDER_THRESHOLD points.

Supports all chart types:

• Line: GPU-instanced line segments via GpuChartLineRenderer
• Scatter: GPU-instanced points via GpuChartScatterRenderer
• Bar: GPU-instanced quads via GpuChartBarRenderer
• Area: GPU-instanced fill + lines via GpuChartAreaRenderer

Performance Characteristics

Operation	CPU Path	GPU Path
Data append	O(n) tessellation	O(n) buffer upload (once)
Pan/zoom	O(n) tessellation	O(1) uniform update
Render	O(n) triangles	O(n) instances

Text Rendering (with chart-text feature)

When the chart-text feature is enabled, use with_text() to add text rendering:

let font_system = FontSystem::with_system_fonts();
let gpu_chart = GpuStreamingChart::new(chart, context.clone(), surface_format)
    .with_text(context.clone(), font_system);

Example

use astrelis_geometry::chart::*;
use astrelis_render::GraphicsContext;
use std::sync::Arc;

let context: Arc<GraphicsContext> = /* ... */;
let surface_format = window.surface_format();
let chart = ChartBuilder::line()
    .add_series("Sensor", &[])
    .interactive(true)
    .build();

let mut gpu_chart = GpuStreamingChart::new(chart, context, surface_format);

// In update loop:
gpu_chart.push_time_point(0, time, value);
gpu_chart.auto_scroll(AxisId::X_PRIMARY, 60.0);

// Before rendering:
let bounds = Rect::new(0.0, 0.0, 800.0, 600.0);
gpu_chart.prepare_render(&bounds);

// In render pass:
gpu_chart.render(&mut pass, viewport, &bounds);

Implementations

impl GpuStreamingChart

pub fn new( chart: Chart, context: Arc<GraphicsContext>, target_format: TextureFormat, ) -> Self

Create a new GPU-accelerated streaming chart.

The target_format must match the render target this chart will draw into.

pub fn from_streaming( streaming: StreamingChart, context: Arc<GraphicsContext>, target_format: TextureFormat, ) -> Self

Create from an existing streaming chart.

The target_format must match the render target this chart will draw into.

pub fn force_gpu_rendering(self, force: bool) -> Self

Force GPU rendering regardless of data size.

Useful for testing or when you know data will grow large.

pub fn chart(&self) -> &Chart

Get a reference to the underlying chart.

pub fn chart_mut(&mut self) -> &mut Chart

Get a mutable reference to the underlying chart.

pub fn streaming(&self) -> &StreamingChart

Get a reference to the underlying streaming chart.

pub fn streaming_mut(&mut self) -> &mut StreamingChart

Get a mutable reference to the underlying streaming chart.

pub fn line_renderer(&self) -> &GpuChartLineRenderer

Get a reference to the GPU line renderer.

pub fn line_renderer_mut(&mut self) -> &mut GpuChartLineRenderer

Get a mutable reference to the GPU line renderer.

pub fn scatter_renderer(&self) -> &GpuChartScatterRenderer

Get a reference to the GPU scatter renderer.

pub fn bar_renderer(&self) -> &GpuChartBarRenderer

Get a reference to the GPU bar renderer.

pub fn area_renderer(&self) -> &GpuChartAreaRenderer

Get a reference to the GPU area renderer.

pub fn is_gpu_enabled(&self) -> bool

Check if GPU rendering is currently enabled.

pub fn append_data(&mut self, series_idx: usize, points: &[DataPoint])

Append data points to a series.

pub fn push_point( &mut self, series_idx: usize, point: DataPoint, max_points: Option<usize>, )

Push a single point with optional sliding window.

pub fn set_data(&mut self, series_idx: usize, data: Vec<DataPoint>)

Replace all data in a series.

pub fn clear_data(&mut self, series_idx: usize)

Clear all data from a series.

pub fn push_time_point(&mut self, series_idx: usize, time: f64, value: f64)

Push a time/value point to a series.

pub fn push_time_point_windowed( &mut self, series_idx: usize, time: f64, value: f64, max_points: usize, )

Push a time/value point with sliding window.

pub fn auto_scroll(&mut self, axis_id: AxisId, window_size: f64)

Configure auto-scrolling for an axis.

pub fn disable_auto_scroll(&mut self, axis_id: AxisId)

Disable auto-scrolling for an axis.

pub fn mark_view_changed(&mut self)

Notify that the view has changed (pan/zoom).

pub fn mark_style_changed(&mut self)

Notify that style has changed.

pub fn mark_bounds_changed(&mut self)

Notify that bounds have changed (widget resized).

pub fn dirty_flags(&self) -> ChartDirtyFlags

Get the current dirty flags.

pub fn prepare_render(&mut self, bounds: &Rect)

Prepare the chart for rendering.

This prepares both the coordinate cache and GPU buffers as needed. Call this once per frame before rendering.

pub fn prepare_render_with_result(&mut self, bounds: &Rect) -> PrepareResult

Prepare with detailed result information.

pub fn render( &self, pass: &mut RenderPass<'_>, viewport: Viewport, geometry_renderer: &mut GeometryRenderer, bounds: &Rect, )

Render the chart to a render pass.

This uses GPU-accelerated rendering for large datasets and falls back to tessellation for small datasets.

Arguments

• pass - The render pass to draw into
• viewport - The viewport for rendering
• geometry_renderer - The geometry renderer for non-GPU elements
• bounds - The chart bounds

pub fn statistics(&self) -> GpuStreamingStatistics

Get statistics about the streaming data.

pub fn get_display_data( &self, series_idx: usize, pixel_width: f32, ) -> Vec<DataPoint>

Get downsampled data for display (for external use like tooltips).

Methods from Deref<Target = Chart>

pub fn series_len(&self, series_idx: usize) -> usize

Get the number of data points in a series.

pub fn total_points(&self) -> usize

Get the total number of data points across all series.

pub fn get_axis(&self, id: AxisId) -> Option<&Axis>

Get an axis by ID.

pub fn x_axis(&self) -> Option<&Axis>

Get the X axis (primary).

pub fn y_axis(&self) -> Option<&Axis>

Get the Y axis (primary).

pub fn data_bounds_for_axis(&self, axis_id: AxisId) -> Option<(f64, f64)>

Get the combined bounds of all series for a specific axis.

pub fn data_bounds(&self) -> Option<(DataPoint, DataPoint)>

Get the combined bounds of all series.

pub fn axis_range(&self, axis_id: AxisId) -> (f64, f64)

Get the effective range for an axis.

pub fn x_range(&self) -> (f64, f64)

Get the effective X range (respecting axis min/max overrides).

pub fn y_range(&self) -> (f64, f64)

Get the effective Y range (respecting axis min/max overrides).

Trait Implementations

impl Debug for GpuStreamingChart

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for GpuStreamingChart

type Target = Chart

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl From<(Chart, Arc<GraphicsContext>, TextureFormat)> for GpuStreamingChart

fn from( (chart, context, target_format): (Chart, Arc<GraphicsContext>, TextureFormat), ) -> Self

Converts to this type from the input type.