Struct RenderContext 

pub struct RenderContext {

    pub(crate) width: u16,
    pub(crate) height: u16,
    pub(crate) paint: PaintType,
    pub(crate) paint_transform: Affine,
    pub(crate) stroke: Stroke,
    pub(crate) transform: Affine,
    pub(crate) fill_rule: Fill,
    pub(crate) temp_path: BezPath,
    pub(crate) aliasing_threshold: Option<u8>,
    pub(crate) encoded_paints: Vec<EncodedPaint>,
    pub(crate) render_settings: RenderSettings,
    dispatcher: Box<dyn Dispatcher>,
    pub(crate) glyph_caches: Option<GlyphCaches>,
}

A render context.

Fields

width: u16

height: u16

paint: PaintType

paint_transform: Affine

stroke: Stroke

transform: Affine

fill_rule: Fill

temp_path: BezPath

aliasing_threshold: Option<u8>

encoded_paints: Vec<EncodedPaint>

render_settings: RenderSettings

dispatcher: Box<dyn Dispatcher>

glyph_caches: Option<GlyphCaches>

Implementations

impl RenderContext

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

Create a new render context with the given width and height in pixels.

pub fn new_with(width: u16, height: u16, settings: RenderSettings) -> Self

Create a new render context with specific settings.

fn encode_current_paint(&mut self) -> Paint

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

Fill a path.

pub fn stroke_path(&mut self, path: &BezPath)

Stroke a path.

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

Fill a rectangle.

fn rect_to_temp_path(&mut self, rect: &Rect)

pub fn fill_blurred_rounded_rect( &mut self, rect: &Rect, radius: f32, std_dev: f32, )

Fill a blurred rectangle with the given radius and standard deviation.

Note that this only works properly if the current paint is set to a solid color. If not, it will fall back to using black as the fill color.

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

Stroke a rectangle.

pub fn glyph_run(&mut self, font: &FontData) -> GlyphRunBuilder<'_, Self>

Creates a builder for drawing a run of glyphs that have the same attributes.

pub fn push_layer( &mut self, clip_path: Option<&BezPath>, blend_mode: Option<BlendMode>, opacity: Option<f32>, mask: Option<Mask>, )

Push a new layer with the given properties.

Note that the mask, if provided, needs to have the same size as the render context. Otherwise, it will be ignored. In addition to that, the mask will not be affected by the current transformation matrix in place.

pub fn push_clip_layer(&mut self, path: &BezPath)

Push a new clip layer.

pub fn push_blend_layer(&mut self, blend_mode: BlendMode)

Push a new blend layer.

pub fn push_opacity_layer(&mut self, opacity: f32)

Push a new opacity layer.

pub fn set_aliasing_threshold(&mut self, aliasing_threshold: Option<u8>)

Set the aliasing threshold.

If set to None (which is the recommended option in nearly all cases), anti-aliasing will be applied.

If instead set to some value, then a pixel will be fully painted if the coverage is bigger than the threshold (between 0 and 255), otherwise it will not be painted at all.

Note that there is no performance benefit to disabling anti-aliasing and this functionality is simply provided for compatibility.

pub fn push_mask_layer(&mut self, mask: Mask)

Push a new mask layer.

Note that the mask, if provided, needs to have the same size as the render context. Otherwise, it will be ignored. In addition to that, the mask will not be affected by the current transformation matrix in place.

pub fn pop_layer(&mut self)

Pop the last-pushed layer.

pub fn set_stroke(&mut self, stroke: Stroke)

Set the current stroke.

pub fn stroke(&self) -> &Stroke

Get the current stroke

pub fn set_paint(&mut self, paint: impl Into<PaintType>)

Set the current paint.

pub fn paint(&self) -> &PaintType

Get the current paint.

pub fn set_paint_transform(&mut self, paint_transform: Affine)

Set the current paint transform.

The paint transform is applied to the paint after the transform of the geometry the paint is drawn in, i.e., the paint transform is applied after the global transform. This allows transforming the paint independently from the drawn geometry.

pub fn paint_transform(&self) -> &Affine

Get the current paint transform.

pub fn reset_paint_transform(&mut self)

Reset the current paint transform.

pub fn set_fill_rule(&mut self, fill_rule: Fill)

Set the current fill rule.

pub fn fill_rule(&self) -> &Fill

Get the current fill rule.

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

Set the current transform.

pub fn transform(&self) -> &Affine

Get the current transform.

pub fn reset_transform(&mut self)

Reset the current transform.

pub fn reset(&mut self)

Reset the render context.

pub fn flush(&mut self)

Flush any pending operations.

This is a no-op when using the single-threaded render mode, and can be ignored. For multi-threaded rendering, you have to call this before rasterizing, otherwise the program will panic.

pub fn render_to_buffer( &self, buffer: &mut [u8], width: u16, height: u16, render_mode: RenderMode, )

Render the current context into a buffer. The buffer is expected to be in premultiplied RGBA8 format with length width * height * 4

pub fn render_to_pixmap(&self, pixmap: &mut Pixmap)

Render the current context into a pixmap.

pub fn width(&self) -> u16

Return the width of the pixmap.

pub fn height(&self) -> u16

Return the height of the pixmap.

pub fn render_settings(&self) -> &RenderSettings

Return the render settings used by the RenderContext.

impl RenderContext

Recording management implementation.

fn generate_strips_from_commands( &mut self, commands: &[RenderCommand], buffers: (StripStorage, Vec<usize>), ) -> (StripStorage, Vec<usize>)

Generate strips from strip commands and capture ranges.

Returns:

• collected_strips: The generated strips.
• collected_alphas: The generated alphas.
• strip_start_indices: The start indices of strips for each geometry command.

impl RenderContext

Recording management implementation.

fn process_geometry_command( &mut self, strip_start_indices: &[usize], range_index: usize, adjusted_strips: &[Strip], )

fn prepare_cached_strips( &mut self, cached_strips: &[Strip], cached_alphas: &[u8], ) -> Vec<Strip>

Prepare cached strips for rendering by adjusting indices.

fn take_current_state(&mut self) -> RenderState

Save the current rendering state.

fn restore_state(&mut self, state: RenderState)

Restore the saved rendering state.

Trait Implementations

impl ColrRenderer for RenderContext

fn push_clip_layer(&mut self, clip: &BezPath)

Push a new clip layer.

fn push_blend_layer(&mut self, blend_mode: BlendMode)

Push a new blend layer.

fn fill_solid(&mut self, color: AlphaColor<Srgb>)

Fill the current area with the given solid color.

fn fill_gradient(&mut self, gradient: Gradient)

Fill the current area with the given gradient color.

fn set_paint_transform(&mut self, affine: Affine)

Set the transform for paints.

fn pop_layer(&mut self)

Pop the last clip/blend layer.

impl Debug for RenderContext

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

Formats the value using the given formatter.

impl GlyphRenderer for RenderContext

fn fill_glyph(&mut self, prepared_glyph: PreparedGlyph<'_>)

Fill glyphs with the current paint and fill rule.

fn stroke_glyph(&mut self, prepared_glyph: PreparedGlyph<'_>)

Stroke glyphs with the current paint and stroke settings.

fn take_glyph_caches(&mut self) -> GlyphCaches

Takes the glyph caches from the renderer for use in a glyph run.

fn restore_glyph_caches(&mut self, cache: GlyphCaches)

Restores the glyph caches after a glyph run.

impl Recordable for RenderContext

fn record<F>(&mut self, recording: &mut Recording, f: F)

where F: FnOnce(&mut Recorder<'_>),

Record rendering commands into a recording.

fn prepare_recording(&mut self, recording: &mut Recording)

Generate sparse strips for a recording.

fn execute_recording(&mut self, recording: &Recording)

Execute a recording directly without preparation.