Struct SceneBuilder 

pub struct SceneBuilder<'a> { /* private fields */ }

Records paint commands into a Scene, maintaining a transform stack.

Widgets call SceneBuilder::push_transform/SceneBuilder::pop_transform around their subtree’s paint calls to compose local offsets/scales with the ancestor transform, mirroring nested widget placement.

Implementations

impl<'a> SceneBuilder<'a>

pub fn new(scene: &'a mut Scene) -> SceneBuilder<'a>

Wraps scene for recording, starting with an identity transform.

The transform stack’s backing allocation lives on scene itself so it’s reused across every call instead of reallocating a fresh Vec per frame — reset here to [Affine::IDENTITY], identical to a freshly allocated stack.

pub fn current_transform(&self) -> Affine

The transform currently in effect (composition of all pushed transforms).

pub fn push_transform(&mut self, transform: Affine)

Pushes a transform, composed with the current one, onto the stack.

Subsequent paint calls use the composed transform until the matching SceneBuilder::pop_transform.

pub fn pop_transform(&mut self)

Pops the most recently pushed transform, restoring the previous one.

A no-op if called without a matching push_transform (the base identity transform is never popped).

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

Records a filled rectangle under the current transform.

pub fn fill_rounded_rect(&mut self, rect: Rect, radius: f64, brush: Brush)

Records a filled rounded rectangle (uniform corner radius) under the current transform.

The uniform-radius spelling of SceneBuilder::fill_rounded_rect_radii — kept verbatim so every existing call site is unaffected by per-corner radii.

pub fn fill_rounded_rect_radii( &mut self, rect: Rect, radii: CornerRadii, brush: Brush, )

Records a filled rounded rectangle with per-corner radii under the current transform.

pub fn stroke_line(&mut self, p0: Point, p1: Point, width: f64, brush: Brush)

Records a stroked line segment from p0 to p1 under the current transform.

pub fn draw_glyph_run(&mut self, glyph_run: GlyphRun)

Records a glyph run, composing its own transform with the current one.

pub fn push_clip(&mut self, rect: Rect)

Pushes a rectangular clip onto the render backend’s clip stack, recording the current transform so the clip is applied in the same space as the draws it encloses.

pub fn push_clip_rounded(&mut self, rect: Rect, radius: f64)

Pushes a clip with uniformly rounded corners (radius, in the pre-transform coordinate space) onto the render backend’s clip stack, recording the current transform so the clip is applied in the same space as the draws it encloses.

Popped by SceneBuilder::pop_clip — the same method that pops a rectangular SceneBuilder::push_clip, since both share one clip stack (see Command::PushClipRounded).

pub fn push_clip_rounded_radii(&mut self, rect: Rect, radii: CornerRadii)

Pushes a clip with per-corner radii onto the render backend’s clip stack, recording the current transform — the per-corner spelling of SceneBuilder::push_clip_rounded, popped by the same SceneBuilder::pop_clip.

pub fn pop_clip(&mut self)

Pops the most recently pushed clip, rectangular or rounded.

pub fn draw_image(&mut self, data: &ImageData, dest: Rect)

Records a decoded image, scaled to fill dest, under the current transform.

data is cloned into the command — cheap, since ImageData’s Blob<u8> is reference-counted internally (see Command::Image).

pub fn draw_blurred_rounded_rect( &mut self, rect: Rect, radius: f64, std_dev: f64, color: AlphaColor<Srgb>, )

Records a gaussian-blurred rounded-rectangle shadow (uniform corner radius) under the current transform (see Command::BlurredRoundedRect).

pub fn draw_blurred_rounded_rect_radii( &mut self, rect: Rect, radii: CornerRadii, std_dev: f64, color: AlphaColor<Srgb>, )

Records a gaussian-blurred rounded-rectangle shadow with per-corner radii under the current transform.

Neither render tier has a per-corner blurred primitive, so a non-uniform shadow lowers through CornerRadii::largest at encode time — see Command::BlurredRoundedRect for why the largest corner and not the smallest.

pub fn push_layer(&mut self, rect: Rect, alpha: f32)

Pushes a translucent layer onto the render backend’s layer stack, recording the current transform (see Command::PushLayer).

pub fn pop_layer(&mut self)

Pops the most recently pushed layer.

pub fn clear_rect(&mut self, rect: Rect)

Records a rectangle cleared to full transparency (alpha 0) under the current transform (see Command::ClearRect) — the platform-view hole-punch. Unlike SceneBuilder::fill_rect with a transparent brush (which composites transparent over the backdrop, a no-op), this erases whatever was already drawn beneath the rect.

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

Records a filled arbitrary vector path (e.g. an arc) under the current transform, using the nonzero winding rule.

pub fn stroke_path(&mut self, path: BezPath, width: f64, brush: Brush)

Records a stroked arbitrary vector path (e.g. an arc), with round caps/joins, under the current transform.

pub fn stroke_path_dashed( &mut self, path: BezPath, width: f64, dash: DashPattern, brush: Brush, )

Records a dashed stroked path under the current transform: the same stroke SceneBuilder::stroke_path records, carrying a DashPattern the render crate expands into dash segments at encode time.

pub fn push_snapshot(&mut self, key: u64, rect: Rect, alpha: f32, scale: f64)

Pushes a snapshot bracket, recording the current transform (see Command::PushSnapshot) and incrementing the scene’s snapshot depth so the matching SceneBuilder::pop_snapshot knows a bracket is open. key identifies the body’s cache entry across frames; rect/alpha/scale are the presentation parameters a renderer may apply on top of the body as a whole.

pub fn pop_snapshot(&mut self)

Pops the most recently pushed snapshot bracket. A no-op — matching Command::PopClip/Command::PopLayer’s unbalanced-pop policy — when no bracket is open.

pub fn draw_shader(&mut self, program: &ShaderProgram, dest: Rect, time: f32)

Records a fragment-shader-filled rectangle, scaled to fill dest, under the current transform (see Command::ShaderQuad).

The engine renders the fragment program in a pre-pass into an offscreen target and draws it over dest. Output is treated as premultiplied alpha. The rendering is disabled by FRUST_ENGINE_NO_SHADER_EFFECTS.

program is cloned into the command — cheap, since ShaderProgram clones its id and its Arc<str> source handle, never the source text. time is seconds, app-supplied.

pub fn scene_texture(&mut self, id: u64, dest: Rect)

Records an externally owned GPU texture, scaled to fill dest, under the current transform (see Command::SceneTexture).

id is opaque scene-layer data — only the render backend resolves it against textures registered with the GPU context; an unregistered id draws nothing.

Trait Implementations

impl PaintScene for SceneBuilder<'_>

Bridges the provisional PaintScene boundary onto the real frust_scene::SceneBuilder.

Widgets paint through &mut dyn PaintScene; the desktop shell hands them a SceneBuilder, so filled rectangles and shaped glyph runs land in the display list under the builder’s current transform. Unshaped PaintScene::draw_text is intentionally dropped here — text must be shaped (by frust-text) into glyph runs before it can be drawn.

fn fill_rect(&mut self, origin: Point, size: Size, color: AlphaColor<Srgb>)

Emit a filled axis-aligned rectangle at origin with size, filled with the solid color.

fn fill_rounded_rect( &mut self, origin: Point, size: Size, radius: f64, color: AlphaColor<Srgb>, )

Emit a filled axis-aligned rectangle with uniformly rounded corners.

fn fill_rounded_rect_radii( &mut self, origin: Point, size: Size, radii: CornerRadii, color: AlphaColor<Srgb>, )

Emit a filled axis-aligned rectangle with per-corner radii — the shape a uniform PaintScene::fill_rounded_rect cannot express (a bottom-anchored sheet with only its top corners rounded, a segmented control’s end caps).

fn stroke_line( &mut self, p0: Point, p1: Point, width: f64, color: AlphaColor<Srgb>, )

Stroke a straight line from p0 to p1 with the given width and solid color.

fn push_clip(&mut self, origin: Point, size: Size)

Push a rectangular clip (at origin/size) onto the backend clip stack; subsequent draws are clipped to it until the matching PaintScene::pop_clip.

fn push_clip_rounded(&mut self, origin: Point, size: Size, radius: f64)

Push a clip with uniformly rounded corners (at origin/size, corner radius) onto the backend clip stack; subsequent draws are clipped to the rounded shape until the matching PaintScene::pop_clip — the same pop PaintScene::push_clip uses, since there is one clip stack.

fn push_clip_rounded_radii( &mut self, origin: Point, size: Size, radii: CornerRadii, )

Push a clip with per-corner radii onto the backend clip stack, popped by the same PaintScene::pop_clip as every other push.

fn pop_clip(&mut self)

Pop the most recently pushed clip, rectangular or rounded. Defaulted to a no-op; see PaintScene::push_clip.

fn draw_text(&mut self, _origin: Point, _text: &str)

Emit a run of unshaped text anchored at origin.

fn draw_glyph_run(&mut self, run: GlyphRun)

Emit a run of already-shaped glyphs into the scene.

fn draw_image(&mut self, data: &ImageData, dest: Rect)

Draw an already-decoded image, scaled from its natural (data.widthxdata.height) size to fill the absolute dest rect.

fn draw_shader(&mut self, program: &ShaderProgram, dest: Rect, time: f32)

Draw a fragment-shader-filled rectangle, scaled to fill dest.

fn draw_scene_texture(&mut self, id: u64, dest: Rect)

Composite a bound scene texture (pre-rendered via ExternalPass) into the scene.

fn draw_shadow( &mut self, origin: Point, size: Size, radius: f64, std_dev: f64, color: AlphaColor<Srgb>, )

Draw a gaussian-blurred rounded-rectangle elevation shadow (an approximation of a CSS box-shadow) at origin/size.

fn fill_rect_brush(&mut self, origin: Point, size: Size, brush: &Brush)

Emit a filled axis-aligned rectangle at origin with size, filled with an arbitrary brush (solid color or gradient).

fn fill_rounded_rect_brush( &mut self, origin: Point, size: Size, radius: f64, brush: &Brush, )

Emit a filled axis-aligned rectangle with uniformly rounded corners, filled with an arbitrary brush (solid color or gradient).

fn push_layer(&mut self, origin: Point, size: Size, alpha: f32)

Push a translucent layer (at origin/size) onto the backend layer stack; subsequent draws are composited at alpha until the matching PaintScene::pop_layer.

fn pop_layer(&mut self)

Pop the most recently pushed layer. Defaulted to a no-op; see PaintScene::push_layer.

fn clear_rect(&mut self, origin: Point, size: Size)

Clear an axis-aligned rectangle (at origin/size) to full transparency (alpha 0), erasing everything already painted below it in this scene — a real destination-clearing composite, not merely skipping paint over the region.

fn fill_path(&mut self, origin: Point, path: &BezPath, brush: &Brush)

Fill an arbitrary vector path (e.g. an arc — see frust_scene::arc_path) at origin, using the nonzero winding rule and brush.

fn stroke_path( &mut self, origin: Point, path: &BezPath, width: f64, brush: &Brush, )

Stroke an arbitrary vector path (e.g. an arc) at origin with width and round caps/joins, using brush.

fn stroke_path_dashed( &mut self, origin: Point, path: &BezPath, width: f64, dash: DashPattern, brush: &Brush, )

Stroke an arbitrary vector path at origin as a dashed line: the same stroke PaintScene::stroke_path paints, broken into dash’s on/off runs by the render crate at encode time.

fn push_transform(&mut self, transform: Affine)

Push an affine transform, composed with the current one, onto the backend transform stack; subsequent draws are transformed until the matching PaintScene::pop_transform.

fn pop_transform(&mut self)

Pop the most recently pushed transform, restoring the previous one. Defaulted to a no-op; see PaintScene::push_transform.

fn push_snapshot( &mut self, key: u64, origin: Point, size: Size, alpha: f32, scale: f64, )

Push a snapshot bracket: the body is rasterizable once and cached by key across frames. The alpha and scale are presentation parameters applied to the whole cached body (alpha blending, uniform scale).

fn pop_snapshot(&mut self)

Pop the most recently pushed snapshot bracket. Defaulted to the reverse of PaintScene::push_snapshot’s default: pop layer, then transform. Recorders that don’t override both may see unbalanced stacks if only one is overridden; the default pair is provided for source compatibility.