Skip to content
Impossible Robert — Unity Tools

Chart Guru API Reference

This reference is generated from the shipped Chart Guru assemblies and their XML documentation.

ChartGuru

Section titled “ChartGuru”
  • AccessibilityInfo — Per-mark accessibility metadata. Mirrors Swift Charts’ .accessibilityLabel , .accessibilityValue , .accessibilityHidden , and .accessibilityIdentifier
  • Animation — Describes how a chart value change animates. Modeled after SwiftUI’s Animation: static factories produce common curves; the fluent Delay/Speed/Repeat
  • Animation.Kind — Internal curve kind. Chosen by the static factories.
  • AnimationField — Serializable wrapper around an optional . Unity cannot serialize Animation? directly, so components expose this struct in their inspector. When is fal
  • AnimationFieldPropertyDrawer — Draws : an Enabled toggle that, when on, reveals the inner Animation drawer. Matches the SwiftUI mental model of “no animation unless explicitly confi
  • AnimationPropertyDrawer — Draws in a shape that mirrors SwiftUI’s Animation API: a curve (Kind) selector plus duration / spring parameters and fluent modifiers (Delay / Speed /
  • AnnotationAlignment — API type
  • AnnotationBoundary — Boundary against which an evaluates. Swift Charts equivalent: AnnotationOverflowResolution.Boundary .
  • AnnotationConfig — API type
  • AnnotationOverflowConfig — Apple-shaped richer overflow resolution carrying per-dimension strategies and a boundary. Swift Charts: AnnotationOverflowResolution.init(x:y:boundary
  • AnnotationOverflowResolution — Strategy for resolving annotations that would overflow the plot area. Swift Charts equivalent: AnnotationOverflowResolution .
  • AnnotationPosition — API type
  • AreaMark — Creates a range AreaMark spanning from yStart to yEnd at the given x position. Swift Charts equivalent: AreaMark(x: .Value(“X”, x), yStart: .Value(“St
  • AreaPlot — A vectorized area plot that renders a mathematical function as a filled area. Swift Charts equivalent: AreaPlot(x: “x”, y: .linearFunction(…))
  • AreaPlot — Vectorized area plot for rendering filled areas from collection data. Swift Charts equivalent: AreaPlot(data, x:, y:)
  • AreaRenderData — Batched area data across all series.
  • AreaSeriesRenderData — Geometry + style for a single area series.
  • AxesRenderData — Axis geometry (baseline, tick positions, colors).
  • AxisBuilder — API type
  • AxisConfig — Configuration data for a chart axis. Contains all settings for axis visibility, domain, styling, ticks, and labels.
  • AxisFormatStyle — High-level formatting mode for axis tick labels. Mirrors Swift Charts’ FormatStyle family without reinventing the whole Foundation API surface. preser
  • AxisLabelAlignment — Cross-axis alignment of the axis title within its reserved zone. Swift Charts equivalent: ChartXAxisLabel(alignment:) / ChartYAxisLabel(alignment:) .
  • AxisLabelAnchor — API type
  • AxisLabelInfo — Information about an axis label for external text rendering.
  • AxisLabelPosition — Along-axis position of the axis title. Swift Charts equivalent: ChartXAxisLabel(position:) / ChartYAxisLabel(position:) .
  • AxisMarkConfig — Configuration for axis mark styling.
  • AxisMarkPosition — Position of axis marks relative to the axis line.
  • AxisMarkPreset — Preset configurations for axis marks. Swift Charts equivalent: AxisMarks(preset: …)
  • AxisMarksBlockBuilder — API type
  • AxisMarksBuilder — Builder for configuring individual axis marks (ticks, grid lines, labels). Swift Charts equivalent: AxisMarks { value in … }
  • AxisMarkValues — Configuration for automatic axis mark values. Swift Charts equivalent: .Automatic(desiredCount: 5)
  • AxisPosition — Axis position within the chart.
  • AxisRenderer — Renders axis lines, ticks, labels, and grid lines.
  • AxisScaleType — User-facing axis scale type. The single canonical control surfaced in every authoring UI (ChartGraphic Inspector, ChartDesignerWindow, ManualChartData
  • AxisTickLength — Composable tick-length spec, settable via AxisBuilder.TickLength(AxisTickLength) . Implicitly converts from a plain float for the common fixed-pixel c
  • AxisTickLengthMode — How the renderer resolves the pixel length of an axis tick. Swift Charts equivalent: AxisTick.Length .
  • AxisTitleInfo — Information about an axis title for external text rendering.
  • AxisValue — Represents a value at an axis mark position. Swift Charts equivalent: AxisValue in AxisMarks { value in … } Access to the value and formatting utili
  • AxisValueLabelCollisionResolution — Apple Swift Charts AxisValueLabelCollisionResolution mirror. Drives how the axis renderer resolves overlapping tick labels.
  • AxisValueLabelCollisionResolution.Strategy — API type
  • AxisValueLabelOrientation — Apple Swift Charts AxisValueLabelOrientation mirror. Forces a specific rotation for axis tick labels, overriding the Auto-rotate “fit?” branch in the
  • AxisValueLabelOrientationExtensions — API type
  • AxisVisibility — Axis visibility state for Swift Charts-style API. Swift Charts equivalent: .ChartXAxis(.hidden) / .ChartXAxis(.visible)
  • BackgroundOverrideState — Plain data container for background override state shared by all chart host components ( , , ChartGuruElement ). Lifted out of the host components so
  • BandScale — Band scale for categorical data. Maps discrete categories to continuous range.
  • BarGeometry — Screen-space geometry for a single bar.
  • BarGPUData — GPU data structure for bar rendering.
  • BarLayout — API type
  • BarLayoutParams — Layout parameters for bar chart slot calculations. This is the single source of truth for bar positioning.
  • BarMark — 1D horizontal bar constructor. Mirrors Swift Charts: BarMark(x: .Value(“Size”, size)) All marks share y=0 and stack horizontally via their series. The
  • BarOrientationMode — Authoring-surface orientation selector that adds an “Automatic” tier on top of . Inspector / serialized fields use this so users can keep the orientat
  • BarPlot — Vectorized bar plot for rendering bars from collection data. Swift Charts equivalent: BarPlot(data, x:, y:)
  • BarRenderData — Geometry for a single bar (plot-space, pixels).
  • BarsRenderData — Batched bar geometry + plot-area / baseline metadata.
  • CandleGeometry — Screen-space geometry for a single candlestick.
  • CandlestickChartBuilder — Helper class for creating Candlestick charts from OHLC data.
  • CandleStickMark — Represents a candlestick mark for financial charts. Composed of: - A body (BarMark) showing open-close range - A wick (RuleMark) showing high-low rang
  • CanvasTextPool — Canvas TextMeshPro label pools organized by text category.
  • CanvasTmpTextRenderer — Canvas text renderer implementation using TextMeshPro.
  • Chart — Represents a fully configured chart, including its marks, axes, theme, layout, interaction state, and animation settings. Create charts through for th
  • Chart3DApplyOptions — Optional style knobs forwarded from to the 3D bridge. Kept as a plain struct so the core assembly doesn’t depend on any 3D-specific types.
  • Chart3DCameraProjection — Camera projection mode for 3D charts. Swift Charts equivalent: Chart3DCameraProjection .
  • Chart3DContent — Marker base type for 3D-aware chart content (Apple parity: Chart3DContent ). Currently exposes the SymbolRotation(_:) modifier; concrete renderers wil
  • Chart3DContentExtensions — Extensions implementing Swift’s Chart3DContent fluent modifiers.
  • Chart3DIntegration — Static IoC bridge that lets the optional ChartGuru.3D add-on register a handler capable of converting 2D / definitions into 3D marks on an target. If
  • Chart3DIntegration.Apply3DDelegate — Signature the ChartGuru.3D bridge registers at startup.
  • Chart3DPose — Camera pose for 3D charts, expressed as azimuth (rotation around Y) and inclination (tilt up/down). Swift Charts equivalent: Chart3DPose . Mirrors Cha
  • ChartAudioGraph — Configuration for chart-level audio graph / sonification export. Swift Charts equivalent: AXChartDescriptorRepresentable conformance and the audioGrap
  • ChartAuthoringBinder — Applies a onto a + pair. Replaces the duplicated RebuildChart / Initialize bodies previously inlined in and by composing the existing and helpers.
  • ChartAuthoringState — Plain-old-data aggregate of the authoring surface shared by every chart host component ( , , ChartGuruElement ). Acts as a translation-layer between t
  • ChartAuthoringStyleApplicator — API type
  • ChartAuthoringStyleOptions — API type
  • ChartBackgroundBinder — Single-source-of-truth applier for background overrides. Replaces the duplicated SyncBackgroundOverridesToRenderer methods that previously lived in bo
  • ChartBackgroundMode — Defines how a chart or plot-area background is painted.
  • ChartBinRange — Range used to describe a histogram bin. Mirrors Swift Charts’ ChartBinRange . Open-bound flags let callers express half-open intervals (the Swift conv
  • ChartBorderConfig — Configuration for a border drawn around the entire chart area.
  • ChartBuilder — Builds a through a Swift Charts-inspired fluent C# API. Add marks and modifiers, then call to resolve defaults, categorical data, scales, layout, and
  • ChartBuilderExtensions — Builder extensions for creating marks from data collections.
  • ChartCanvasHelper — Helper methods for easily rendering charts to a Unity Canvas. Swift Charts-style simplicity for programmatic chart creation. Usage: // Render to full
  • ChartCategory — API type
  • ChartColorUtils — Utility methods for color calculations in charts.
  • ChartColumnType — Inferred type of a column in a parsed tabular dataset.
  • ChartColumnTypeInferrer — Heuristic column-type inference. Samples up to maxSamplesPerColumn non-empty cells per column and votes between , , , and . A column is classified onl
  • ChartComponent — Hosts a Chart Guru chart on a GameObject for component-driven authoring and runtime updates. Use when the chart should render inside a uGUI Canvas.
  • ChartConfigurationApplicator — API type
  • ChartConfigurationOptions — API type
  • ChartDataEntry — Serializable data point for inspector-based chart data entry.
  • ChartDataEntryDrawer — Property drawer for that adapts the X editor to the connected chart’s axis type: • Numeric → standard float field (with Has Explicit X toggle) • Time
  • ChartDataEntryPositionUtility — API type
  • ChartDataMapping — Inspector-editable mapping that tells a file/live data source which columns of a parsed become which axes. Two flavours of multi-series data are suppo
  • ChartDataMappingSuggester — Heuristic mapping suggester. Given a parsed returns a that “does the right thing” for the most common shapes. Rules (in order): If the table has colum
  • ChartDataSeries — Serializable data series for multi-series charts.
  • ChartDataSourceBase — Abstract base class for chart data sources. Shared functionality for populating ChartGraphic with data.
  • ChartDesignerWindow — API type
  • ChartDimension — API type
  • ChartEditorGUI — Shared utility for drawing ChartGuru text overlays (axis labels, data labels, legend) in Unity Editor GUI contexts (Inspector, EditorWindow, etc.). Us
  • ChartEditorTextOptions — Options for . All fields are optional — sensible defaults are derived from the Chart’s theme.
  • ChartFileDataSourceBase — Common base for every data source that parses a text payload (CSV, JSON, Google Sheets export, an HTTP body, …) into a , then maps it through a to p
  • ChartFileSourceMode — How a file-based data source locates its source text.
  • ChartFileSourceResolver — Helper used by and to resolve the configured source mode/path to raw text. Centralizing this keeps both inspectors consistent and avoids duplicated I/
  • ChartFontStyle — Font style options shared by Chart Guru text surfaces.
  • ChartGalleryCard — Represents a gallery card entry. Extended to support feature demonstrations in addition to standard chart types.
  • ChartGalleryWindow — API type
  • ChartGesture — Represents a chart gesture configuration for handling user interactions. Swift Charts equivalent: .chartGesture { proxy in DragGesture()… }
  • ChartGesturePhase — Gesture phase for tracking gesture lifecycle.
  • ChartGestureType — Gesture type enumeration matching common gesture patterns.
  • ChartGraphic — Renders a Chart Guru chart inside a Unity UI Canvas and exposes runtime data, configuration, animation, and pointer-interaction entry points.
  • ChartGraphicEditor — Custom editor for ChartGraphic with conditional field visibility based on chart type.
  • ChartInspector — Custom inspector for Chart component.
  • ChartInteractionController — Backend-neutral interaction controller shared by every chart host component ( , , ChartGuruElement ). Consumes chart-space pointer positions (pixels,
  • ChartLayoutConstants — Centralized layout constants for consistent positioning across all chart rendering paths. These values are the single source of truth for all position
  • ChartLayoutConstants.ChartPadding — Represents padding values for a chart’s plot area.
  • ChartLayoutEngine — Renderer-agnostic layout engine for charts. Computes all positions, sizes, and layout data needed for rendering. This is the single source of truth fo
  • ChartMark — API type
  • ChartMarkFactory — API type
  • ChartMeshPool — Pool of reusable meshes for chart rendering. Reduces GC allocations by recycling mesh instances.
  • ChartMorpher — Drives value and chart-type transitions. Interpolates previous-to-current mark values via a Burst job using an curve.
  • ChartMorphRenderer — The single morph-aware piece of code in ChartGuru. Given a source and target chart type plus a normalised t , projects both ends of the transition to
  • ChartMorphStyle — API type
  • ChartOverlayRectangleEntry — API type
  • ChartProxy — Coordinate mapping and hit detection for charts. Similar to ChartProxy in Swift Charts, enables interaction between screen coordinates and data space.
  • ChartRenderer — Main chart renderer that orchestrates all rendering operations. Uses GL immediate mode for Editor compatibility and clean anti-aliased output. Renderi
  • ChartScrollTargetBehavior — API type
  • ChartTabularData — Lightweight, in-memory tabular dataset shared by every ChartGuru file and live data source. Produced by ChartGuru.DataSources.Parsers.CsvParser and Ch
  • ChartTabularDataToMarks — Stateless conversion from a parsed + a to a list of s shaped for the requested . Supports long-format (one Y column + a series-by category column) and
  • ChartTabularRow — Read-only view of a single row in a .
  • ChartTextAlignment — Text alignment options shared by Chart Guru’s Canvas, UI Toolkit, and IMGUI text surfaces.
  • ChartTextDefaults — Shared default text options for Chart Guru labels.
  • ChartTextManager — Text rendering for charts. Coordinates text pools, label positioning, and formatting.
  • ChartTextManager.RadarLabelInfo — Lightweight descriptor for a free-positioned label used by radar decorations (ring tick values and spoke-tip category labels).
  • ChartTextOptions — Configuration options for chart text rendering. Backend-agnostic settings shared by Canvas TMP labels, UI Toolkit labels, and editor previews.
  • ChartTheme — API type
  • ChartThemeEditor — Custom inspector for that shows gradient controls only for the currently selected background mode.
  • ChartTitlePosition — Position and alignment for the chart title/subtitle block. Encodes both vertical placement (top/bottom) and horizontal alignment (leading/center/trail
  • ChartType — Available chart types. Aligned with Swift Charts mark-based approach. Includes compact/tiny chart variants for inline display.
  • ChartTypeExtensions — Extension methods for ChartType enum providing centralized chart type categorization.
  • ClipShape — Shape used to clip a mark’s rendered output. Swift Charts equivalent: .ClipShape(…) .
  • ClosedRange — Represents a closed range [lowerBound, upperBound]. Swift Charts equivalent: ClosedRange<T> (e.g., 0.0…100.0) Used for range-based selection A
  • ClosedRange.RangeBuilder — API type
  • ClosedRangeExtensions — Extension methods for creating ClosedRange instances.
  • ColorScale — Represents a color scale for mapping values to colors, supporting both: - Gradient-based continuous color scales (for numerical data like heatmaps) -
  • ColorScale.ColorScaleType — API type
  • ColorScaleLegendInfo — Information for rendering a continuous color scale legend bar (e.g. for heatmaps).
  • CompositeChartMark — Base class for composite marks that expand into multiple primitive marks. Common functionality for managing visibility, series key, and colors.
  • ComputeBufferManager — ComputeBuffer management for GPU data upload. Buffer lifecycle, resizing, and data updates.
  • CoordinateSystem — Defines the coordinate system used for layout calculations.
  • CsvChartDataSource — Reads CSV (or any separated-values text) from a TextAsset, project file, absolute path, StreamingAssets file, or inline string and pushes it to one
  • CsvChartDataSourceEditor — API type
  • CsvHeaderMode — API type
  • CsvParseOptions — Options for . Sensible defaults match the most common spreadsheet exports (RFC 4180 with auto-detected delimiter and header).
  • CsvParser — Hand-rolled, allocation-conscious RFC 4180 CSV parser with delimiter auto-detection. Returns a . Handles quoted fields (including escaped “” ), CR/LF/
  • DataLabelInfo — Information about a data label for external text rendering.
  • DataLabelPosition — Position options for data labels relative to data points.
  • DataMode — Data mode for chart data sources.
  • DataPoint — A single data point for chart rendering. Blittable struct optimized for GPU upload. Size: 32 bytes for cache-line friendly layout.
  • DataPoint3D — Extended data point with Z-axis for 3D charts. Prepared for future 3D support. Size: 48 bytes.
  • DataSeries — Create and add a new series with the given key.
  • DataSeries — API type
  • DateBins — Date bin specification. Swift Charts equivalent: DateBins . Uses calendar units rather than raw seconds for human-friendly histogram boundaries.
  • DateBins.Kind — API type
  • DirtyFlags — API type
  • DrawMaterial — Material bucket requested by the renderer. The GL sink maps these to its two cached materials ( _glMaterial , _glAAMaterial ); UI Toolkit sinks interp
  • DrawTopology — Geometry topology requested by the renderer when calling . Mirrors the subset of GL topologies the existing emits. Sinks that only natively accept tri
  • Easing — Public easing preset for ChartGuru.UIToolkit.ChartGuruElement.AnimationEasing. Each value maps to an factory method.
  • Edge — Edges flags used by . Swift Charts equivalent: Edge.Set (.leading, .trailing, .top, .bottom, .horizontal, .vertical, .all). Leading == left, Trailing
  • ExponentialRegressionResult — Result of an exponential regression calculation (y = a·e^(bx)).
  • ForegroundStyleMode — Controls how is assigned to marks in single-series charts. Mirrors Swift Charts’ .ForegroundStyle(by:) modifier.
  • FourCornerGradient — Stores one colour per corner of a rectangle and supports bilinear colour evaluation. Coordinate convention: Y is up (bottom-left = (0,0), top-right =
  • FunctionScaleTransformer — Convenience: build an from delegates.
  • GalleryEntryType — Type of gallery entry.
  • GLDrawSink — that forwards to GL immediate mode, preserving the exact behaviour of the pre-sink renderer. Owns the two shared materials the renderer previously hel
  • GLDrawSink.FrameScope — Disposable scope returned from . Disposing it pops the GL pixel matrix, matching the pre-sink GL.PushMatrix / GL.PopMatrix pairing at the top of Chart
  • GoogleSheetsChartDataSource — Convenience wrapper around that converts a Google Sheets share URL into the matching CSV-export URL, then pulls + parses it on a configurable interval
  • GoogleSheetsChartDataSourceEditor — API type
  • GradientStop — A color stop at an explicit location within a gradient. Swift Charts equivalent: Gradient.Stop(color: .red, location: 0.5) .
  • GradientStyle — Apple Swift Charts gradient discriminated union mirror. Concrete subclasses are , , , and . All four gradient types are fully realised with 2D samplin
  • GradientStyle.Angular — API type
  • GradientStyle.Elliptical — API type
  • GradientStyle.Linear — API type
  • GradientStyle.Radial — API type
  • GridRenderData — Grid-line positions + styling, in plot-space pixels.
  • HeatMapBuilder — Helper class for creating HeatMap charts with automatic grid generation and color scale application. Matches Swift Charts’ approach to heatmap creatio
  • IChart3DHost — Minimal host contract that lets 2D implementations (ManualChartDataSource, MockChartDataSource, …) push data into 3D chart targets without taking a ha
  • IChartContent — Interface for composite chart content that can expand into multiple marks. This enables complex visualizations like CandleStickMark that are composed
  • IChartDataSource — Minimal contract shared by every ChartGuru data source - the MonoBehaviour (scene-authored) and the new ChartDataSourceAsset (ScriptableObject, projec
  • IChartDrawSink — Backend-neutral immediate-mode draw target used by to emit geometry without binding to a specific rendering pipeline. Implementations in this project:
  • IChartHost — Common minimal contract implemented by any chart host (2D , 3D Chart3DComponent , future hosts). Lets data sources, editor tooling, and gizmos refer t
  • IChartMark — API type
  • IChartTextRenderer — Canvas label renderer used by Chart Guru’s uGUI surface.
  • IMarkColorResolver — The morph layer’s sole colour-resolution hook. Per-mark colours are read straight from / / (which already applied the theme palette, per-mark override
  • InterpolationMethod — API type
  • IScaleTransformer — Pluggable axis scale transformer. Swift Charts equivalent: ScaleTransformer (used by ChartXScale(transformer:) / ChartYScale(transformer:) ).
  • JsonChartDataSource — Reads JSON from a TextAsset, project file, absolute path, StreamingAssets file, or an inline string and converts it to chart marks. Supports a JSONPat
  • JsonChartDataSourceEditor — API type
  • JsonToTabular — Converts JSON text to a using Newtonsoft.Json’s JToken.SelectTokens for full JSONPath support. The selector should resolve to one of: An array of obje
  • LabelContext — Context data for label formatting.
  • LabelFormatter — Formats label text using placeholder tokens. Supports placeholders like {value}, {series}, {category}, {percent}, etc.
  • LabelRotation — Label rotation presets for axis labels.
  • LayoutMetrics — Stores computed layout metrics for a chart, organized by layers from chart edges inward. Layer 0: Chart edge padding Layer 0.5: Chart title/subtitle b
  • LayoutSnapshot — A snapshot of all layout data from ChartLayoutEngine. Use this to get layout in a specific coordinate system.
  • LeaderLineGraphic — UI Graphic component for rendering leader lines connecting pie labels to slices. Uses Unity’s UI mesh system for proper Canvas integration.
  • LeaderLineGraphic.LeaderLine — Represents a single leader line.
  • LegendAlignment — Alignment for legend within its position area. Swift Charts equivalent: .ChartLegend(position:alignment:)
  • LegendConfig — API type
  • LegendItem — Represents a legend item.
  • LegendItemBuilder — Mutable, callback-scoped view of a legend entry passed to . The same instance may be reused across entries and layout passes, so callbacks should not
  • LegendLabelInfo — Information about a legend label for external text rendering.
  • LegendPosition — API type
  • LegendSeriesInfo — API type
  • LegendVisibility — Legend visibility state for Swift Charts-style API. Swift Charts equivalent: .ChartLegend(.hidden) / .ChartLegend(.visible) / .ChartLegend(.automatic)
  • LinearGradientPreset — API type
  • LinearGradientStyle — API type
  • LinearRegression3D — Result of a bivariate linear regression calculation for 3D charts. Represents the plane y = a + bx + cz.
  • LinearRegressionResult — Result of a linear regression calculation.
  • LinearScale — Linear scale with uniform mapping.
  • LineCap — Line cap style - how line endpoints are rendered. Swift Charts equivalent: CGLineCap
  • LineJoin — Line join style - how corners are rendered. Swift Charts equivalent: CGLineJoin
  • LineLayoutParams — Layout parameters for line/area charts.
  • LineMark — Plots connected data points as a line with configurable interpolation, symbols, and stroke styling.
  • LinePlot — A vectorized line plot that renders a mathematical function. Swift Charts equivalent: LinePlot(x: “x”, y: .linearFunction(intercept: 0, slope: 1)) Unl
  • LinePlot — Vectorized line plot for rendering lines from collection data. Swift Charts equivalent: LinePlot(data, x:, y:)
  • LinePointGPUData — GPU data structure for line point rendering.
  • LineSeriesRenderData — Geometry + style for a single line series.
  • LinesRenderData — Batched line data across all series.
  • LineTessellator — CPU-side line tessellator shared by sinks that cannot natively emit line primitives (for example UITKMeshDrawSink , whose only accepts indexed triangl
  • LODController — Controls Level of Detail for chart rendering. Dynamically adjusts quality based on point count and viewport.
  • LODSettings — Settings for LOD behavior.
  • LogarithmicRegressionResult — Result of a logarithmic regression calculation (y = a + b·ln(x)).
  • LogScale — Logarithmic scale for exponential data.
  • LogScaleHelper — Generates “nice” tick values for a logarithmic axis. Emits decade boundaries (powers of ) inside the requested raw-data range, with optional intra-dec
  • MajorValueAlignment — Major alignment specification for value-aligned scroll snapping. Swift Charts equivalent: MajorValueAlignment .
  • MajorValueAlignment.AlignmentKind — API type
  • ManagedPlottableValue — Managed wrapper for PlottableValue that supports string categories directly. Use this for convenience API; it converts to native types internally for
  • ManualChartDataSource — Component for defining chart data manually in the Inspector. Attach to the same GameObject as ChartGraphic or reference a ChartGraphic. Supports singl
  • ManualChartDataSourceEditor — Custom inspector for ManualChartDataSource. Shows/hides fields based on the selected DataMode.
  • ManualChartReferenceRule — API type
  • MarkAxis — Axis along which a mark’s grouping applies. Swift Charts equivalent: Axis enum consumed by Position(by:axis:) .
  • MarkBlendMode — Blend mode applied to a mark during compositing. Swift Charts equivalent: .BlendMode(…) .
  • MarkComposition — Snapshot of which mark kinds are present in a ’s mark list. Drives the renderer and layout-engine’s mark-kind dispatch (Swift Charts parity: every kin
  • MarkDimension — Represents a size/dimension specification for marks. Swift Charts equivalent: MarkDimension for width/height/size parameters. Supports fixed pixel val
  • MarkDimensions — Apple Swift Charts MarkDimensions<DataElement> mirror. Holds optional per-element selectors that produce a for the width and/or height of each g
  • MarkDimensionType — Specifies the type of dimension specification.
  • MarkExtensions — Extension methods for fluent series grouping and styling. Swift Charts-style modifiers.
  • MarkShape — Pure data describing a single mark’s geometry in screen space. Produced by and consumed by the morph recipes — never touched by the per-type renderers
  • MarkShapeBatch — Result of : a complete description of one chart-type’s marks in screen space, decoupled from the per-type renderer. Used by to interpolate between sou
  • MarkShapeKind — Discriminator for .
  • MarkStackingMethod — Controls how marks stack when multiple values share the same position. Matches Swift Charts MarkStackingMethod.
  • MeasurementFormat — Locale-aware unit-bearing number formatter, modelled on Apple’s Measurement<UnitType>.FormatStyle . Fluent style configurable for Width ( ), uni
  • MeasurementUnitKind — Common unit kinds. Use + a string for arbitrary symbols.
  • MockChart3DDataShape — Shape applied when generated mock data is sent to a 3D chart target.
  • MockChartDataSource — Component for generating mock chart data using the MockData system. Supports one-shot generation and continuous streaming with full configuration. Wor
  • MockChartDataSourceEditor — Custom inspector for MockChartDataSource.
  • MockDataMode — How to handle incoming mock data when streaming.
  • MockLabelOverflowMode — API type
  • MorphInterpolationJob — API type
  • MorphOptions — Options for a chart-type transition ( ). The animation curve is provided via , matching the rest of the API.
  • MorphState — API type
  • NumberBins — Numeric bin specification. Swift Charts equivalent: NumberBins . Use for fixed bin counts, for caller-supplied edges, or for a target bin width.
  • NumberBins.Kind — API type
  • OHLCData — OHLC data structure for candlestick charts.
  • PieLabelMode — Positioning mode for pie/donut chart data labels.
  • PieLayoutParams — Layout parameters for pie/donut charts.
  • PlotDimensionRange — Plot-dimension scale range padding. Swift Charts equivalent: .plotDimension(startPadding:endPadding:) . Pads (or — when negative — extends) the value/
  • PlotGroup — A logical grouping container for chart marks that participate in scales as one unit. Swift Charts equivalent: Plot { … } (iOS 17). Marks inside a Pl
  • PlotGroupBuilder — Builder for constructing a with a subset of methods.
  • PlotStyleBuilder — Builder for fluent plot style configuration. Swift Charts equivalent: .chartPlotStyle { $0.Background(.blue) }
  • PlotStyleConfig — Configuration for plot area styling. Swift Charts equivalent of .chartPlotStyle { } modifier.
  • PlottableProjection — Factory methods for creating instances.
  • PlottableProjection<TElement, TValue> — Type-safe projection from a data element to a plottable value. Swift Charts equivalent: PlottableProjection<DataElement, DataValue> with typed k
  • PlottableType — Defines the type of data for automatic scale and axis inference.
  • PlottableValue — Static factory methods for creating PlottableValues with automatic type inference. Swift Charts-style .Value(“Label”, data) syntax.
  • PlottableValue — A labeled value for chart data binding. The label is used for axis titles, tooltips, and legends. This is a high-performance unmanaged struct optimize
  • PlottableValueRef — Non-generic wrapper for PlottableValue to allow usage as parameter type. Used for Swift Charts-style APIs like ForegroundStyle(by: .Value(“Label”, dat
  • PointDecimator — Point decimation algorithms for reducing data at lower LOD levels.
  • PointGeometry — Screen-space geometry for a single point.
  • PointGPUData — GPU data structure for point/scatter rendering.
  • PointMapping — API type
  • PointMark — Plots an individual data point using a configurable symbol, size, rotation, fill, and stroke.
  • PointPlot — Vectorized point plot for rendering points from collection data. Swift Charts equivalent: PointPlot(data, x:, y:)
  • PointRenderData — Geometry for a single scatter/point.
  • PointsRenderData — Batched point geometry + plot area.
  • PolylineTopology — One series-level polyline (line chart series, area chart series). Tracks the marks the line connects (by reference into ) plus the visual style needed
  • PolynomialRegressionResult — Result of a polynomial regression calculation.
  • PowerRegressionResult — Result of a power regression calculation (y = a·x^b).
  • ProjectionFamily — Coarse-grained projection family that decides which rendering pipeline a chart runs through. A chart belongs to exactly one family; mark kinds inside
  • RadarDomainHelper — Shared helper that resolves the radial-axis upper bound used to normalize radar-mark values into the [0..1] polygon radius. Mirrors the “extend displa
  • RadarLabelLayout — Shared layout helper that builds the list of radar chart decoration labels (Y-axis ring tick values along the top spoke + X-axis spoke-tip category la
  • RadarMark — API type
  • RadarRenderData — Radar / spider chart geometry.
  • RadarRingStyle — Controls how concentric tick rings on a radar chart are drawn.
  • RadarSeriesData — Single radar Series (normalized values).
  • RadialLabelPositioner — Label positioning for radial charts (pie, donut) with collision avoidance. Places labels outside the chart with leader lines connecting to slices.
  • RadialLabelPositioner.Config — Configuration for radial label positioning.
  • RadialLabelPositioner.PositionedLabel — Result of label positioning calculation.
  • RadialLabelPositioner.SliceLabel — Data for a pie slice label.
  • RangedOffset — Range-based offset for marks in domain coordinates. When a field is null on a given axis, layout falls back to the mark’s inherent position on that ax
  • RectangleMark — RectangleMark for heatmaps, range charts, and grid-based visualizations. Matches Swift Charts RectangleMark(xStart:xEnd:yStart:yEnd:) API.
  • RectanglePlot — Vectorized rectangle plot for rendering rectangles from collection data. Swift Charts equivalent: RectanglePlot(data, xStart:, xEnd:, yStart:, yEnd:)
  • RegressionType — Regression types supported for trend line calculations.
  • RenderDataPoint — GPU-ready data point for shader upload. Minimal data for rendering. Size: 16 bytes (fits in float4).
  • RingBufferChartDataSource — High-throughput live data source built around a fixed-capacity ring buffer. Producers call / from anywhere (including hot game-loop code or a backgrou
  • RingBufferChartDataSourceEditor — API type
  • Rotation3D — 3D rotation expressed as Euler angles in degrees (Apple Swift parity: Rotation3D from RealityKit / SwiftCharts3D ).
  • RuleMark — API type
  • RulePlot — Vectorized rule plot for rendering rules from collection data. Swift Charts equivalent: RulePlot(data, x:) or RulePlot(data, y:)
  • RuleRenderData — Geometry + style for a single rule line.
  • RulesRenderData — Batched rule-line geometry (horizontal + vertical reference lines).
  • Scale — Base class for all scale types. Maps data values to visual positions.
  • ScaleType — Scale type enumeration for scale configuration. Swift Charts equivalent: ScaleType parameter in chartXScale/chartYScale
  • ScrollableAxes — Scrollable axis configuration for viewport-based charts. Swift Charts equivalent: .ChartScrollableAxes(.horizontal/.vertical)
  • ScrollTargetContext — Context passed to so context-sensitive behaviors (Page / Matching / LimitBehavior) can resolve.
  • SectorGeometry — Screen-space geometry for a single pie/donut sector.
  • SectorGPUData — GPU data structure for sector rendering.
  • SectorMark — Creates a SectorMark with the given Value (angle proportion). Swift Charts equivalent: SectorMark(angle: .Value(“Value”, value))
  • SectorPlot — Vectorized sector plot for rendering pie/donut sectors from collection data. Swift Charts equivalent: SectorPlot(data, angle:, innerRadius:, outerRadi
  • SectorRenderData — Geometry for a single pie/donut sector.
  • SectorsRenderData — Batched sector geometry + pie layout metadata.
  • SelectionIndicatorStyle — Selection indicator style for charts. Controls how selected/hovered data points are highlighted.
  • SelectionRenderData — Selection overlay geometry (crosshair + dot intersections).
  • SeriesCollection — Non-generic version using string keys for Unity serialization.
  • SeriesCollection — A collection of data series with change notification support. Automatically assigns series indices and manages dirty state.
  • SeriesGradientOverride — Per-series gradient override for .
  • SonificationNote — A single note in a sonification sequence — frequency, onset time, duration, and volume.
  • SonificationOptions — Tuning parameters for audio-graph sonification output. Swift Charts equivalent: options passed through the AXChartDescriptorRepresentable protocol con
  • StackedShadowExtent — Bounding extent of a single stacked-bar category for shadow/glow rendering. Computed per-category during bar geometry so renderers can draw one shadow
  • StrokeStyle — The characteristics of a stroke that traces a path. Swift Charts equivalent: StrokeStyle Usage: // Solid 2px line var solid = new StrokeStyle(lineWidt
  • SurfaceStyle — Surface styling options shared between the core Chart model and the 3D add-on. Swift Charts equivalent: Chart3DSurfaceStyle .
  • SwiftChartsDefaults — Canonical Swift Charts defaults used as the single source of truth for the code generator, Swift importer, mark constructors, and ChartBuilder. Values
  • Symbol3D — Symbols used for 3D point marks. Swift Charts equivalent: sphere/cylinder/cone symbol styles on PointMark in Chart3D.
  • SymbolShape — API type
  • SymbolShapeExtensions — Fluent extensions on mirroring Swift Charts’ BasicChartSymbolShape.StrokeBorder(lineWidth:) .
  • SymbolShapeResolver — Centralized symbol shape resolution for semantic series encoding. Used by both ChartRenderer (for drawing) and ChartLayoutEngine (for legend layout).
  • SymbolStyle — Combines a with optional stroke-border styling. Constructed via or implicit conversion from for filled symbols. Swift Charts equivalent: BasicChartSym
  • TextCategory — Categories of text elements in a chart for pooling purposes.
  • ThemePalettes — API type
  • TickLabel — Represents a tick label with its value, text, and screen position.
  • TimeAxisHelper — Utilities for converting between and the float “axis seconds” values that flow through the rendering pipeline, and for generating calendar-aligned tic
  • TimeScale — Time scale for temporal data.
  • TimeUnit — API type
  • TinyChartConfig — API type
  • TinyChartFit — API type
  • TinyMinMaxRenderData — Min/max indicator geometry used by tiny charts (sparklines).
  • TopologyAdapter — Decorator over an that only natively accepts and synthesizes the other topologies by buffering the incoming vertex stream per batch and converting on
  • TrendLinePlot — First-class trend line mark that wraps regression calculations into a renderable chart mark implementing . Swift Charts equivalent: LinearRegressionPl
  • TrendLineUtils — Utility class for calculating regression trend lines from data points. Supports linear, polynomial (degree 2-6), exponential, logarithmic, and power r
  • UnitPoint — API type
  • UnitWidth — Width of a unit token (Apple parity: FormatStyle.UnitWidth ).
  • ValueAlignedLimitBehavior — Controls how a value-aligned snap clamps results against the data domain. Swift Charts equivalent: ValueAlignedLimitBehavior .
  • WebChartDataSource — Polls an HTTP/HTTPS endpoint on a configurable interval, decodes the response as CSV or JSON, and pushes the result through the standard mapping pipel
  • WebChartDataSource.HttpHeader — API type
  • WebChartDataSourceEditor — API type
  • WebDataFormat — Format detection / override for .
  • WelcomeWindow — API type
  • YahooFinanceChartDataSource — Convenience data source that pulls OHLCV candles from the public Yahoo Finance chart endpoint ( https://query1.finance.yahoo.com/v8/finance/chart/{sym
  • YahooFinanceInterval — Yahoo Finance candle interval. Note: long ranges only support coarse intervals (Yahoo rejects 1m for ranges > 7 days, etc.). Stick to the defaults
  • YahooFinanceRange — Yahoo Finance candle ranges available on the public chart endpoint.