Enum epaint::Shape

pub enum Shape {
    Noop,
    Vec(Vec<Shape>),
    Circle(CircleShape),
    LineSegment {
        points: [Pos2; 2],
        stroke: Stroke,
    },
    Path(PathShape),
    Rect(RectShape),
    Text(TextShape),
    Mesh(Mesh),
    QuadraticBezier(QuadraticBezierShape),
    CubicBezier(CubicBezierShape),
    Callback(PaintCallback),
}

A paint primitive such as a circle or a piece of text. Coordinates are all screen space points (not physical pixels).

You should generally recreate your Shapes each frame, but storing them should also be fine with one exception: Shape::Text depends on the current pixels_per_point (dpi scale) and so must be recreated every time pixels_per_point changes.

Variants

Noop

Paint nothing. This can be useful as a placeholder.

Vec(Vec<Shape>)

Recursively nest more shapes - sometimes a convenience to be able to do. For performance reasons it is better to avoid it.

Circle(CircleShape)

Circle with optional outline and fill.

LineSegment

Fields

points: [Pos2; 2]

stroke: Stroke

A line between two points.

Path(PathShape)

A series of lines between points. The path can have a stroke and/or fill (if closed).

Rect(RectShape)

Rectangle with optional outline and fill.

Text(TextShape)

Text.

This needs to be recreated if pixels_per_point (dpi scale) changes.

Mesh(Mesh)

A general triangle mesh.

Can be used to display images.

QuadraticBezier(QuadraticBezierShape)

A quadratic Bézier Curve.

CubicBezier(CubicBezierShape)

A cubic Bézier Curve.

Callback(PaintCallback)

Backend-specific painting.

Implementations

impl Shape

Constructors

pub fn line_segment(points: [Pos2; 2], stroke: impl Into<Stroke>) -> Self

A line between two points. More efficient than calling Self::line.

pub fn hline(x: RangeInclusive<f32>, y: f32, stroke: impl Into<Stroke>) -> Self

A horizontal line.

pub fn vline(x: f32, y: RangeInclusive<f32>, stroke: impl Into<Stroke>) -> Self

A vertical line.

pub fn line(points: Vec<Pos2>, stroke: impl Into<Stroke>) -> Self

A line through many points.

Use Self::line_segment instead if your line only connects two points.

pub fn closed_line(points: Vec<Pos2>, stroke: impl Into<Stroke>) -> Self

A line that closes back to the start point again.

pub fn dotted_line(
    path: &[Pos2],
    color: impl Into<Color32>,
    spacing: f32,
    radius: f32
) -> Vec<Self>

Turn a line into equally spaced dots.

pub fn dashed_line(
    path: &[Pos2],
    stroke: impl Into<Stroke>,
    dash_length: f32,
    gap_length: f32
) -> Vec<Self>

Turn a line into dashes.

pub fn dashed_line_many(
    points: &[Pos2],
    stroke: impl Into<Stroke>,
    dash_length: f32,
    gap_length: f32,
    shapes: &mut Vec<Shape>
)

Turn a line into dashes. If you need to create many dashed lines use this instead of Self::dashed_line

pub fn convex_polygon(
    points: Vec<Pos2>,
    fill: impl Into<Color32>,
    stroke: impl Into<Stroke>
) -> Self

A convex polygon with a fill and optional stroke.

The most performant winding order is clockwise.

pub fn circle_filled(
    center: Pos2,
    radius: f32,
    fill_color: impl Into<Color32>
) -> Self

pub fn circle_stroke(center: Pos2, radius: f32, stroke: impl Into<Stroke>) -> Self

pub fn rect_filled(
    rect: Rect,
    rounding: impl Into<Rounding>,
    fill_color: impl Into<Color32>
) -> Self

pub fn rect_stroke(
    rect: Rect,
    rounding: impl Into<Rounding>,
    stroke: impl Into<Stroke>
) -> Self

pub fn text(
    fonts: &Fonts,
    pos: Pos2,
    anchor: Align2,
    text: impl ToString,
    font_id: FontId,
    color: Color32
) -> Self

pub fn galley(pos: Pos2, galley: Arc<Galley>) -> Self

pub fn galley_with_color(
    pos: Pos2,
    galley: Arc<Galley>,
    text_color: Color32
) -> Self

The text color in the Galley will be replaced with the given color.

pub fn mesh(mesh: Mesh) -> Self

pub fn image(texture_id: TextureId, rect: Rect, uv: Rect, tint: Color32) -> Self

pub fn visual_bounding_rect(&self) -> Rect

The visual bounding rectangle (includes stroke widths)

impl Shape

Inspection and transforms

pub fn texture_id(&self) -> TextureId

pub fn translate(&mut self, delta: Vec2)

Move the shape by this many points, in-place.

Trait Implementations

impl Clone for Shape

fn clone(&self) -> Shape

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Shape

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

Formats the value using the given formatter.

impl From<CircleShape> for Shape

fn from(shape: CircleShape) -> Self

Converts to this type from the input type.

impl From<CubicBezierShape> for Shape

fn from(shape: CubicBezierShape) -> Self

Converts to this type from the input type.

impl From<Mesh> for Shape

fn from(mesh: Mesh) -> Self

Converts to this type from the input type.

impl From<PaintCallback> for Shape

fn from(shape: PaintCallback) -> Self

Converts to this type from the input type.

impl From<PathShape> for Shape

fn from(shape: PathShape) -> Self

Converts to this type from the input type.

impl From<QuadraticBezierShape> for Shape

fn from(shape: QuadraticBezierShape) -> Self

Converts to this type from the input type.

impl From<RectShape> for Shape

fn from(shape: RectShape) -> Self

Converts to this type from the input type.

impl From<TextShape> for Shape

fn from(shape: TextShape) -> Self

Converts to this type from the input type.

impl From<Vec<Shape, Global>> for Shape

fn from(shapes: Vec<Shape>) -> Self

Converts to this type from the input type.

impl PartialEq<Shape> for Shape

fn eq(&self, other: &Shape) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Shape