Struct OverlayShapeItem 

pub struct OverlayShapeItem {

    pub position: [f32; 2],
    pub size: [f32; 2],
    pub shape: OverlayShape,
    pub fill: OverlayFill,
    pub opacity: f32,
    pub border_colour: [f32; 4],
    pub border_width: f32,
    pub border_mode: BorderMode,
    pub z_order: i32,
    pub texture: Option<OverlayTextureId>,
    pub shadow_colour: [f32; 4],
    pub shadow_radius: f32,
    pub shadow_offset: [f32; 2],
    pub animation: OverlayAnimation,
    pub backdrop_blur: f32,
}

A screen-space overlay shape rendered with a signed-distance function.

Each item becomes a single bounding quad on the GPU. The fragment shader evaluates an SDF to produce anti-aliased fill, border, and discard regions.

fill controls the interior colour. Use OverlayFill::Solid for a flat colour or OverlayFill::LinearGradient for a two-colour gradient.

When texture is set the shape samples the uploaded image as its fill. In that case fill must be OverlayFill::Solid; the solid colour acts as a tint multiplied with each texel. Use [1.0, 1.0, 1.0, 1.0] for no tint. The SDF boundary, border, and AA apply the same way regardless of fill mode.

Examples

// Rounded-rect panel background.
let panel = OverlayShapeItem {
    position: [20.0, 20.0],
    size: [300.0, 200.0],
    shape: OverlayShape::Rect { corner_radius: 8.0 },
    fill: OverlayFill::Solid([0.1, 0.1, 0.1, 0.85]),
    border_width: 1.0,
    border_colour: [0.4, 0.4, 0.4, 1.0],
    ..Default::default()
};

// Circle with a left-to-right gradient.
let grad_dot = OverlayShapeItem {
    position: [100.0, 100.0],
    size: [60.0, 60.0],
    shape: OverlayShape::Circle,
    fill: OverlayFill::LinearGradient {
        start_colour: [0.0, 0.4, 1.0, 1.0],
        end_colour: [0.0, 1.0, 0.5, 1.0],
        angle: 0.0,
    },
    ..Default::default()
};

Fields

position: [f32; 2]

Top-left position in logical pixels from the viewport top-left.

size: [f32; 2]

Width and height in logical pixels.

shape: OverlayShape

Which SDF shape to render.

fill: OverlayFill

Fill style: solid colour or linear gradient.

When texture is Some only OverlayFill::Solid is used; the colour becomes a tint multiplied with each texture sample.

opacity: f32

Overall opacity multiplier applied to both fill and border. Range 0.0-1.0.

border_colour: [f32; 4]

RGBA border colour in linear float format.

border_width: f32

Border thickness in logical pixels. 0.0 disables the border.

border_mode: BorderMode

Where the border sits relative to the shape edge. Default: Inset.

z_order: i32

Draw order relative to other shapes. Lower values render first (further back).

texture: Option<OverlayTextureId>

Optional texture fill. When set the shape samples the image uploaded via ViewportGpuResources::upload_overlay_texture, clipped by the SDF boundary. fill acts as a tint when this is Some.

shadow_colour: [f32; 4]

RGBA colour of the outer shadow/glow halo. Default: transparent (no shadow).

shadow_radius: f32

Blur spread of the shadow in logical pixels. 0.0 disables the shadow.

shadow_offset: [f32; 2]

Offset of the shadow centre from the shape centre in logical pixels. Positive X shifts right, positive Y shifts down. Default: [0.0, 0.0].

animation: OverlayAnimation

Opacity animation. Resolved each frame during prepare() using OverlayFrame::time. Default: OverlayAnimation::None.

backdrop_blur: f32

Backdrop blur radius in logical pixels. When greater than zero the scene content behind the shape is blurred (frosted glass effect) and the fill colour is composited on top as a tint. 0.0 disables the effect. Only active in render paths where the renderer owns the command encoder (render, render_viewport); in paint/paint_to paths blur shapes fall back to a regular solid fill.

Implementations

impl OverlayShapeItem

pub fn distance(&self, point: [f32; 2]) -> f32

Signed distance from a screen-space point to the shape boundary.

The point is in logical pixels from the top-left of the viewport (the same coordinate space as position). Negative values mean the point is inside the shape; positive values mean it is outside.

This evaluates the same SDF used by the GPU shader, so the boundary matches what is rendered on screen (ignoring sub-pixel AA).

pub fn contains(&self, point: [f32; 2]) -> bool

Returns true if the screen-space point falls inside the shape boundary.

The point is in logical pixels from the top-left of the viewport. Equivalent to self.distance(point) <= 0.0.

Trait Implementations

impl Clone for OverlayShapeItem

fn clone(&self) -> OverlayShapeItem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OverlayShapeItem

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

Formats the value using the given formatter.

impl Default for OverlayShapeItem

fn default() -> Self

Returns the “default value” for a type.