Struct Scene 

pub struct Scene { /* private fields */ }

The main datatype for rendering graphics.

A Scene stores a sequence of drawing commands, their context, and the associated resources, which can later be rendered.

Most users will render this using Renderer::render_to_texture.

Rendering from a Scene will not clear it, which should be done in a separate step, by calling Scene::reset.

If this is not done for a scene which is retained (to avoid allocations) between frames, this will likely quickly increase the complexity of the render result, leading to crashes or potential host system instability.

Implementations

impl Scene

pub fn new() -> Scene

Creates a new scene.

pub fn reset(&mut self)

Removes all content from the scene.

pub fn encoding(&self) -> &Encoding

Returns the underlying raw encoding.

pub fn encoding_mut(&mut self) -> &mut Encoding

Returns a mutable reference to the underlying raw encoding.

This can be used to more easily create invalid scenes, and so should be used with care.

pub fn push_layer<'a>( &mut self, clip_style: impl Into<StyleRef<'a>>, blend: impl Into<BlendMode>, alpha: f32, transform: Affine, clip: &impl Shape, )

Pushes a new layer clipped by the specified shape and composed with previous layers using the specified blend mode.

The clip_style controls how the clip shape is interpreted.

• Use Fill to clip to the interior of the shape, with the chosen fill rule.
• Use Stroke (via &Stroke) to clip to the stroked outline of the shape.

Every drawing command after this call will be clipped by the shape until the layer is popped. For layers which are only added for clipping, you should use push_clip_layer instead.

However, the transforms are not saved or modified by the layer stack. That is, the transform argument to this function only applies a transform to the clip shape.

pub fn push_luminance_mask_layer<'a>( &mut self, clip_style: impl Into<StyleRef<'a>>, alpha: f32, transform: Affine, clip: &impl Shape, )

Pushes a new layer clipped by the specified shape and treated like a luminance mask for the current layer.

That is, content drawn between this and the matching pop_layer call will serve as a luminance mask for the prior content in this layer.

The clip_style controls how the clip shape is interpreted.

• Use Fill to clip to the interior of the shape, with the chosen fill rule.
• Use Stroke (via &Stroke) to clip to the stroked outline of the shape.

Every drawing command after this call will be clipped by the shape until the layer is popped.

However, the transforms are not saved or modified by the layer stack. That is, the transform argument to this function only applies a transform to the clip shape.

Transparency and premultiplication

In the current version of Vello, this can lead to some unexpected behaviour when it is used to draw directly onto a render target which disregards transparency (which includes surfaces in most cases). This happens because the luminance mask only impacts the transparency of the returned value, so if the transparency is ignored, it looks like the result had no effect.

This issue only occurs if there are no intermediate opaque layers, so can be worked around by drawing something opaque (or having an opaque base_color), then putting a layer around your entire scene with a Compose::SrcOver.

pub fn push_clip_layer<'a>( &mut self, clip_style: impl Into<StyleRef<'a>>, transform: Affine, clip: &impl Shape, )

Pushes a new layer clipped by the specified clip shape.

The clip_style controls how the clip shape is interpreted.

• Use Fill to clip to the interior of the shape, with the chosen fill rule.
• Use Stroke (via &Stroke) to clip to the stroked outline of the shape.

The pushed layer is intended to not impact the “source” for blending; that is, any blends within this layer will still include content from before this method was called in the “source” of that blend operation. Note that this is not currently implemented correctly - see #1198. As such, you should currently not include any blend layers until this layer is popped.

Every drawing command after this call will be clipped by the shape until the layer is popped.

However, the transforms are not saved or modified by the layer stack. That is, the transform argument to this function only applies a transform to the clip shape.

pub fn pop_layer(&mut self)

Pops the current layer.

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

Draw a rounded rectangle blurred with a gaussian filter.

pub fn draw_blurred_rounded_rect_in( &mut self, shape: &impl Shape, transform: Affine, rect: Rect, brush: AlphaColor<Srgb>, radius: f64, std_dev: f64, )

Draw a rounded rectangle blurred with a gaussian filter in shape.

For performance reasons, shape should not extend more than approximately 2.5 times std_dev away from the edges of rect (as any such points will not be perceptably painted to, but calculations will still be performed for them).

This method effectively draws the blurred rounded rectangle clipped to the given shape. If just the blurred rounded rectangle is desired without clipping, use the simpler Self::draw_blurred_rounded_rect. For many users, that method will be easier to use.

pub fn fill<'b>( &mut self, style: Fill, transform: Affine, brush: impl Into<Brush<ImageBrush<&'b ImageData>, &'b Gradient>>, brush_transform: Option<Affine>, shape: &impl Shape, )

Fills a shape using the specified style and brush.

pub fn stroke<'b>( &mut self, style: &Stroke, transform: Affine, brush: impl Into<Brush<ImageBrush<&'b ImageData>, &'b Gradient>>, brush_transform: Option<Affine>, shape: &impl Shape, )

Strokes a shape using the specified style and brush.

pub fn draw_image<'b>( &mut self, image: impl Into<ImageBrush<&'b ImageData>>, transform: Affine, )

Draws an image at its natural size with the given transform.

pub fn draw_glyphs(&mut self, font: &FontData) -> DrawGlyphs<'_>

Returns a builder for encoding a glyph run.

pub fn append(&mut self, other: &Scene, transform: Option<Affine>)

Appends a child scene.

The given transform is applied to every transform in the child. This is an O(N) operation.

Trait Implementations

impl Clone for Scene

fn clone(&self) -> Scene

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Scene

fn default() -> Scene

Returns the “default value” for a type.

impl From<Encoding> for Scene

fn from(encoding: Encoding) -> Scene

Converts to this type from the input type.