hephaestus 0.2.0

Backend-agnostic 2D scene renderer for data visualization.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

#![cfg_attr(docsrs, feature(doc_cfg))]
//! `hephaestus` — backend-agnostic 2D scene renderer for data visualization.
//!
//! The public API is the [`scene::SceneBuilder`] trait (what plot
//! code calls) plus the [`backend::Renderer`] trait (what produces
//! pixels). Backends slot in behind cargo features; the initial backend is
//! Vello (GPU compute via wgpu).
//!
//! The intersection of Vello and Blend2D capabilities defines the public
//! surface: no conic Beziers, no stroke alignment, no exotic blend modes, no
//! filter effects. Backend-specific extensions are not exposed.

pub mod backend;
pub mod blend;
pub mod brush;
pub mod color;
pub mod composition;
#[cfg(any(feature = "document-read", feature = "document-write"))]
pub mod document;
pub mod geometry;
#[cfg(any(feature = "png", feature = "jpeg", feature = "tiff", feature = "webp"))]
pub mod image;
pub mod layout;
pub mod linetype;
pub mod mesh;
pub mod path;
pub mod pick;
pub mod plot;
pub mod primitives;
pub mod scales;
pub mod scene;
pub mod shape;
pub mod stroke;
pub mod style_vocab;

#[cfg(feature = "png")]
pub mod png;

// `canvas` only has a host to compile on wasm (`wgpu::SurfaceTarget::Canvas`
// is web-only), so on any other target that feature leaves the module out
// entirely rather than pulling in an unreachable one.
#[cfg(any(
    feature = "window",
    all(feature = "canvas", target_arch = "wasm32"),
    all(feature = "webgl", target_arch = "wasm32")
))]
pub mod window;

pub mod text;

// Curated re-exports: the types a caller touches writing a
// hello-world against either API level. Anything more specialised is
// reached through its own module path.
pub use blend::{BlendMode, Compose, Mix};
pub use brush::{Brush, Sampling};
pub use color::{lerp_color, rgb, rgb8, rgba, Color, ColorSpace};
pub use geometry::{Affine, Point, Rect, Size, Vec2};
pub use layout::{
    Axis, Cell, CellId, Extent, Grid, Inset, Layout, Measure, Placement, Respect, Track, WidthHint,
};
pub use linetype::LinetypeStep;
pub use mesh::Mesh;
pub use path::{FillRule, Path};
pub use pick::PickId;
pub use primitives::{
    annular_wedge, arc, circle, clip_polyline, ellipse, offset_polygon, path_to_rings, polygon,
    polyline, rect, regular_polygon, regular_polygon_vertices, round_corners, round_path_corners,
    rounded_rect, segment, wedge, ArcLengthWalker, ArcSample, CornerRounding, EndClip,
    PolygonOptions, PolylineOptions, PolylineSampler, RibbonOptions, TrailingPolicy,
};
pub use scene::{Font, Glyph, GlyphRun, SceneBuilder};
pub use shape::{Shape, ShapeRegistry, ShapeStyle};
pub use stroke::Stroke;
pub use style_vocab::{HAlign, Length, Margin, Palette, ThemeColor, VAlign};

pub use backend::{BackendError, Renderer};

#[cfg(any(feature = "vello", feature = "vello-hybrid"))]
pub use backend::WgpuRenderer;

/// Re-export of the `wgpu` crate version `hephaestus` is built against, so
/// callers integrating the GPU rendering path (see [`WgpuRenderer`]) can pin
/// to the exact types the backend expects.
#[cfg(any(feature = "vello", feature = "vello-hybrid"))]
pub use wgpu;