Struct PaintContext 

pub struct PaintContext { /* private fields */ }

The paint context used for custom 2D drawing

PaintContext wraps a RecordingContext to record draw commands, while providing a Canvas-like API for convenience.

Implementations

impl PaintContext

pub fn new(width: f32, height: f32) -> Self

Create a new paint context with the given viewport size

pub fn from_size(size: Size) -> Self

Create from a Size

pub fn commands(&self) -> &[DrawCommand]

Get all recorded commands

pub fn take_commands(&mut self) -> Vec<DrawCommand>

Take ownership of recorded commands

pub fn fill_rect_xywh( &mut self, x: f32, y: f32, width: f32, height: f32, brush: impl Into<Brush>, )

Fill a rectangle at (x, y) with width/height and a brush

pub fn stroke_rect_xywh( &mut self, x: f32, y: f32, width: f32, height: f32, stroke: &Stroke, brush: impl Into<Brush>, )

Stroke a rectangle at (x, y) with width/height

pub fn fill_rounded_rect_xywh( &mut self, x: f32, y: f32, width: f32, height: f32, radius: f32, brush: impl Into<Brush>, )

Fill a rounded rectangle

pub fn fill_circle_xyr( &mut self, cx: f32, cy: f32, radius: f32, brush: impl Into<Brush>, )

Fill a circle at (cx, cy) with radius

pub fn stroke_circle_xyr( &mut self, cx: f32, cy: f32, radius: f32, stroke: &Stroke, brush: impl Into<Brush>, )

Stroke a circle at (cx, cy) with radius

pub fn draw_text_simple( &mut self, text: impl Into<String>, x: f32, y: f32, size: f32, color: Color, )

Draw text at (x, y) with size and color

pub fn translate(&mut self, x: f32, y: f32)

Push a translation transform

pub fn scale(&mut self, sx: f32, sy: f32)

Push a scale transform

pub fn rotate(&mut self, angle: f32)

Push a rotation transform (angle in radians)

Trait Implementations

impl Default for PaintContext

fn default() -> Self

Returns the “default value” for a type.

impl DrawContext for PaintContext

fn push_transform(&mut self, transform: Transform)

Push a transform onto the stack

fn pop_transform(&mut self)

Pop the top transform from the stack

fn current_transform(&self) -> Transform

Get the current combined transform

fn push_clip(&mut self, shape: ClipShape)

Push a clip shape onto the stack

fn pop_clip(&mut self)

Pop the top clip from the stack

fn push_opacity(&mut self, opacity: f32)

Push an opacity value (multiplied with parent)

fn pop_opacity(&mut self)

Pop the top opacity from the stack

fn push_blend_mode(&mut self, mode: BlendMode)

Push a blend mode

fn pop_blend_mode(&mut self)

Pop the top blend mode from the stack

fn fill_path(&mut self, path: &Path, brush: Brush)

Fill a path with a brush

fn stroke_path(&mut self, path: &Path, stroke: &Stroke, brush: Brush)

Stroke a path

fn fill_rect(&mut self, rect: Rect, corner_radius: CornerRadius, brush: Brush)

Fill a rectangle (convenience method)

fn stroke_rect( &mut self, rect: Rect, corner_radius: CornerRadius, stroke: &Stroke, brush: Brush, )

Stroke a rectangle (convenience method)

fn fill_circle(&mut self, center: Point, radius: f32, brush: Brush)

Fill a circle (convenience method)

fn stroke_circle( &mut self, center: Point, radius: f32, stroke: &Stroke, brush: Brush, )

Stroke a circle (convenience method)

fn draw_text(&mut self, text: &str, origin: Point, style: &TextStyle)

Draw text at a position

fn draw_image(&mut self, image: ImageId, rect: Rect, options: &ImageOptions)

Draw an image

fn draw_shadow( &mut self, rect: Rect, corner_radius: CornerRadius, shadow: Shadow, )

Draw a drop shadow (renders outside the shape)

fn draw_inner_shadow( &mut self, rect: Rect, corner_radius: CornerRadius, shadow: Shadow, )

Draw an inner shadow (renders inside the shape, like CSS inset box-shadow)

fn draw_circle_shadow(&mut self, center: Point, radius: f32, shadow: Shadow)

Draw a circle drop shadow with radially symmetric blur

fn draw_circle_inner_shadow( &mut self, center: Point, radius: f32, shadow: Shadow, )

Draw a circle inner shadow (renders inside the circle)

fn sdf_build(&mut self, f: &mut dyn FnMut(&mut dyn SdfBuilder))

Build SDF shapes using the optimized SDF pipeline

fn set_camera(&mut self, camera: &Camera)

Set the camera for 3D rendering

fn draw_mesh(&mut self, mesh: MeshId, material: MaterialId, transform: Mat4)

Draw a mesh with a material

fn draw_mesh_instanced(&mut self, mesh: MeshId, instances: &[MeshInstance])

Draw instanced meshes

fn add_light(&mut self, light: Light)

Add a light to the scene

fn set_environment(&mut self, env: &Environment)

Set the environment (skybox, IBL)

fn billboard_draw( &mut self, size: Size, transform: Mat4, facing: BillboardFacing, f: &mut dyn FnMut(&mut dyn DrawContext), )

Embed 2D content in the current 3D context as a billboard

fn viewport_3d_draw( &mut self, rect: Rect, camera: &Camera, f: &mut dyn FnMut(&mut dyn DrawContext), )

Embed a 3D viewport in the current 2D context

fn push_layer(&mut self, config: LayerConfig)

Begin an offscreen layer

fn pop_layer(&mut self)

End the current offscreen layer

fn sample_layer(&mut self, id: LayerId, source_rect: Rect, dest_rect: Rect)

Sample from a named layer’s output

fn viewport_size(&self) -> Size

Get the current viewport size

fn is_3d_context(&self) -> bool

Check if we’re in a 3D context

fn current_opacity(&self) -> f32

Get the current opacity

fn current_blend_mode(&self) -> BlendMode

Get the current blend mode

fn set_foreground_layer(&mut self, _is_foreground: bool)

Set whether we’re rendering to the foreground layer (after glass)

fn set_z_layer(&mut self, _layer: u32)

Set the current z-layer for rendering

fn z_layer(&self) -> u32

Get the current z-layer

fn set_3d_transform(&mut self, _rx_rad: f32, _ry_rad: f32, _perspective_d: f32)

Set 3D rotation and perspective for the current element

fn set_3d_shape( &mut self, _shape_type: f32, _depth: f32, _ambient: f32, _specular: f32, )

Set 3D shape parameters for the current element

fn set_3d_light(&mut self, _direction: [f32; 3], _intensity: f32)

Set 3D light parameters for the current element

fn set_3d_translate_z(&mut self, _z: f32)

Set translate-z offset for 3D elements (positive = toward viewer)

fn set_3d_group_raw(&mut self, _shapes: &[[f32; 16]])

Set group shape descriptors for compound 3D rendering Each shape is 16 floats: [offset(4), params(4), half_ext(4), color(4)]

fn clear_3d(&mut self)

Reset 3D transient state to defaults

fn set_css_filter( &mut self, _grayscale: f32, _invert: f32, _sepia: f32, _hue_rotate_deg: f32, _brightness: f32, _contrast: f32, _saturate: f32, )

Set CSS filter parameters for the current element

fn clear_css_filter(&mut self)

Reset CSS filter state to identity

fn set_mask_gradient(&mut self, _params: [f32; 4], _info: [f32; 4])

Set mask gradient parameters for the current element params: linear=(x1,y1,x2,y2), radial=(cx,cy,r,0) in pixel coords info: [mask_type, start_alpha, end_alpha, 0] where mask_type: 0=none, 1=linear, 2=radial

fn clear_mask_gradient(&mut self)

Clear mask gradient state

fn set_corner_shape(&mut self, _shape: [f32; 4])

Set corner shape (superellipse n parameter) for the current element. Values: [top_left, top_right, bottom_right, bottom_left]. n=1.0 = round (default), n=0.0 = bevel, n=2.0 = squircle, n=-1.0 = scoop.

fn clear_corner_shape(&mut self)

Clear corner shape to default (round, n=1.0)

fn set_overflow_fade(&mut self, _fade: [f32; 4])

Set overflow fade distances for the next push_clip. Values: [top, right, bottom, left] in CSS pixels.

fn clear_overflow_fade(&mut self)

Clear pending overflow fade

fn fill_rect_with_per_side_border( &mut self, rect: Rect, corner_radius: CornerRadius, brush: Brush, border_widths: [f32; 4], border_color: Color, )

Fill a rectangle with per-side borders (all same color) Border format: [top, right, bottom, left] Default implementation draws fill then strokes with max border width

fn draw_sdf_viewport(&mut self, _rect: Rect, _viewport: &Sdf3DViewport)

Draw an SDF 3D viewport using GPU raymarching

fn draw_particles(&mut self, _rect: Rect, _particle_data: &ParticleSystemData)

Draw GPU-accelerated particles