🥮 mooncakes.io
    Sign in

    wzzc-dev/moui_sun/graphics does not have a README file

    Surface

    source
    pub(open) trait Surface {
      fn get_width(Self) -> Int
      fn get_height(Self) -> Int
      fn present_pixels(Self, width : Int, height : Int, row_bytes : Int, pixels : FixedArray[Byte]) -> Result[Unit, PresentError]
      fn present_pixels_rect(Self, x : Int, y : Int, width : Int, height : Int, row_bytes : Int, pixels : FixedArray[Byte]) -> Result[Unit, PresentError]
    }

    Destination for CPU-rendered RGBA pixels.

    BlendMode

    source
    pub(all) enum BlendMode {
      Clear
      Source
      Destination
      SourceOver
      DestinationOver
      SourceIn
      DestinationIn
      SourceOut
      DestinationOut
      SourceAtop
      DestinationAtop
      Xor
      Multiply
      Screen
      Add
      Darken
      Lighten
      Difference
      Exclusion
      Overlay
      HardLight
      SoftLight
      ColorDodge
      ColorBurn
      Hue
      Saturation
      Color
      Luminosity
      LinearBurn
      Subtract
    } derive(Eq, 
    Debug    )

    Pixel blend mode used when compositing paint over destination pixels.

    BlendMode::equal

    source
    fn BlendMode::equal(BlendMode, BlendMode) -> Bool

    BlendMode::not_equal

    source
    fn BlendMode::not_equal(x : BlendMode, y : BlendMode) -> Bool

    BlendMode::to_repr

    source

    BmpInfo

    source

    BmpInfo::to_repr

    source

    Canvas

    source
    pub struct Canvas {
      pixmap : Pixmap
      transform : Transform
      clip_rect : Rect?
      state_stack : Array[CanvasState]
      dirty_region : DirtyRegion
    } derive(
    Debug    )

    2D drawing canvas backed by a pixmap

    Canvas::clear

    source
    fn Canvas::clear(self : Canvas, color : Color) -> Unit

    Clear the canvas with a color

    Canvas::clear_clip

    source
    fn Canvas::clear_clip(self : Canvas) -> Unit

    Clear the current clip rectangle.

    Canvas::clear_dirty_region

    source
    fn Canvas::clear_dirty_region(self : Canvas) -> Unit

    Clear accumulated dirty rectangles.

    Canvas::concat_transform

    source
    fn Canvas::concat_transform(self : Canvas, transform : Transform) -> Unit

    Concatenate a transform onto the current transform.

    Canvas::dirty_present_batch

    source
    fn[S : Surface] Canvas::dirty_present_batch(self : Canvas, surface : S, max_rects : Int) -> Result[PresentBatch, PresentError]

    Canvas::dirty_present_plan

    source
    fn[S : Surface] Canvas::dirty_present_plan(self : Canvas, surface : S, max_rects : Int) -> DirtyPresentPlan

    Canvas::draw_mask

    source
    fn Canvas::draw_mask(self : Canvas, x : Int, y : Int, width : Int, height : Int, mask : FixedArray[Byte], paint : Paint) -> Unit

    Draw a grayscale coverage mask with the given paint

    Canvas::draw_mask_rect

    source
    fn Canvas::draw_mask_rect(self : Canvas, x : Int, y : Int, mask_width : Int, mask_height : Int, mask : FixedArray[Byte], src_rect : PixelRect, paint : Paint) -> Unit

    Draw a source rectangle from a grayscale coverage mask with the given paint.

    Canvas::draw_nine_patch_pixmap

    source
    fn Canvas::draw_nine_patch_pixmap(self : Canvas, src : Pixmap, x : Int, y : Int, width : Int, height : Int, insets : NinePatchInsets, paint : Paint, sampling : ImageSampling) -> Unit

    Draw a source pixmap using nine-patch scaling.

    Canvas::draw_pixel

    source
    fn Canvas::draw_pixel(self : Canvas, x : Int, y : Int, color : Color) -> Unit

    Draw a single pixel (for testing)

    Canvas::draw_pixmap

    source
    fn Canvas::draw_pixmap(self : Canvas, src : Pixmap, x : Int, y : Int, paint : Paint) -> Unit

    Draw a source pixmap at the given destination position.

    Canvas::draw_pixmap_rect

    source
    fn Canvas::draw_pixmap_rect(self : Canvas, src : Pixmap, src_rect : PixelRect, x : Int, y : Int, paint : Paint) -> Unit

    Draw a source pixmap rectangle at the given destination position.

    Canvas::draw_placeholder_text

    source
    fn Canvas::draw_placeholder_text(self : Canvas, text : String, x : Double, y : Double, font_size : Double, color : Color) -> Unit

    Draw placeholder text boxes at the given position.

    Canvas::draw_quality_nine_patch_pixmap

    source
    fn Canvas::draw_quality_nine_patch_pixmap(self : Canvas, src : Pixmap, x : Int, y : Int, width : Int, height : Int, insets : NinePatchInsets, paint : Paint, quality : ImageQuality) -> Unit

    Draw a source pixmap using nine-patch scaling and a quality strategy.

    Canvas::draw_quality_pixmap

    source
    fn Canvas::draw_quality_pixmap(self : Canvas, src : Pixmap, x : Int, y : Int, width : Int, height : Int, paint : Paint, quality : ImageQuality) -> Unit

    Draw a source pixmap scaled with a quality strategy.

    Canvas::draw_quality_pixmap_rect

    source
    fn Canvas::draw_quality_pixmap_rect(self : Canvas, src : Pixmap, src_rect : PixelRect, x : Int, y : Int, width : Int, height : Int, paint : Paint, quality : ImageQuality) -> Unit

    Draw a source pixmap rectangle scaled with a quality strategy.

    Canvas::draw_sampled_pixmap

    source
    fn Canvas::draw_sampled_pixmap(self : Canvas, src : Pixmap, x : Int, y : Int, width : Int, height : Int, paint : Paint, sampling : ImageSampling) -> Unit

    Draw a source pixmap scaled with an explicit sampling mode.

    Canvas::draw_sampled_pixmap_rect

    source
    fn Canvas::draw_sampled_pixmap_rect(self : Canvas, src : Pixmap, src_rect : PixelRect, x : Int, y : Int, width : Int, height : Int, paint : Paint, sampling : ImageSampling) -> Unit

    Draw a source pixmap rectangle scaled with an explicit sampling mode.

    Canvas::draw_scaled_pixmap

    source
    fn Canvas::draw_scaled_pixmap(self : Canvas, src : Pixmap, x : Int, y : Int, width : Int, height : Int, paint : Paint) -> Unit

    Draw a source pixmap scaled to the given destination rectangle.

    Canvas::draw_scaled_pixmap_bicubic

    source
    fn Canvas::draw_scaled_pixmap_bicubic(self : Canvas, src : Pixmap, x : Int, y : Int, width : Int, height : Int, paint : Paint) -> Unit

    Draw a source pixmap scaled with bicubic sampling.

    Canvas::draw_scaled_pixmap_bilinear

    source
    fn Canvas::draw_scaled_pixmap_bilinear(self : Canvas, src : Pixmap, x : Int, y : Int, width : Int, height : Int, paint : Paint) -> Unit

    Draw a source pixmap scaled with bilinear sampling.

    Canvas::draw_scaled_pixmap_rect

    source
    fn Canvas::draw_scaled_pixmap_rect(self : Canvas, src : Pixmap, src_rect : PixelRect, x : Int, y : Int, width : Int, height : Int, paint : Paint) -> Unit

    Draw a source pixmap rectangle scaled to the given destination rectangle.

    Canvas::draw_scaled_pixmap_rect_bicubic

    source
    fn Canvas::draw_scaled_pixmap_rect_bicubic(self : Canvas, src : Pixmap, src_rect : PixelRect, x : Int, y : Int, width : Int, height : Int, paint : Paint) -> Unit

    Draw a source pixmap rectangle scaled with bicubic sampling.

    Canvas::draw_scaled_pixmap_rect_bilinear

    source
    fn Canvas::draw_scaled_pixmap_rect_bilinear(self : Canvas, src : Pixmap, src_rect : PixelRect, x : Int, y : Int, width : Int, height : Int, paint : Paint) -> Unit

    Draw a source pixmap rectangle scaled with bilinear sampling.

    Canvas::draw_tiled_pixmap_rect

    source
    fn Canvas::draw_tiled_pixmap_rect(self : Canvas, src : Pixmap, src_rect : PixelRect, x : Int, y : Int, width : Int, height : Int, paint : Paint) -> Unit

    Draw a source pixmap rectangle repeatedly into the destination rectangle.

    Canvas::draw_transformed_quality_pixmap

    source
    fn Canvas::draw_transformed_quality_pixmap(self : Canvas, src : Pixmap, x : Double, y : Double, width : Double, height : Double, paint : Paint, quality : ImageQuality) -> Unit

    Draw a source pixmap transformed by the current transform using a quality strategy.

    Canvas::draw_transformed_quality_pixmap_rect

    source
    fn Canvas::draw_transformed_quality_pixmap_rect(self : Canvas, src : Pixmap, src_rect : PixelRect, x : Double, y : Double, width : Double, height : Double, paint : Paint, quality : ImageQuality) -> Unit

    Draw a source pixmap rectangle transformed by the current transform using a quality strategy.

    Canvas::draw_transformed_sampled_pixmap

    source
    fn Canvas::draw_transformed_sampled_pixmap(self : Canvas, src : Pixmap, x : Double, y : Double, width : Double, height : Double, paint : Paint, sampling : ImageSampling) -> Unit

    Draw a source pixmap transformed by the current canvas transform.

    Canvas::draw_transformed_sampled_pixmap_rect

    source
    fn Canvas::draw_transformed_sampled_pixmap_rect(self : Canvas, src : Pixmap, src_rect : PixelRect, x : Double, y : Double, width : Double, height : Double, paint : Paint, sampling : ImageSampling) -> Unit

    Draw a source pixmap rectangle transformed by the current canvas transform.

    Canvas::fill_circle

    source
    fn Canvas::fill_circle(self : Canvas, cx : Double, cy : Double, radius : Double, paint : Paint) -> Unit

    Draw a filled circle.

    Canvas::fill_ellipse

    source
    fn Canvas::fill_ellipse(self : Canvas, cx : Double, cy : Double, rx : Double, ry : Double, paint : Paint) -> Unit

    Draw a filled ellipse.

    Canvas::fill_path

    source
    fn Canvas::fill_path(self : Canvas, path : Path, paint : Paint) -> Unit

    Fill a path with the given paint

    Canvas::fill_pie

    source
    fn Canvas::fill_pie(self : Canvas, cx : Double, cy : Double, radius : Double, start_angle : Double, sweep_angle : Double, paint : Paint) -> Unit

    Draw a filled pie slice.

    Canvas::fill_polygon

    source
    fn Canvas::fill_polygon(self : Canvas, points : Array[Point], paint : Paint) -> Unit

    Draw a filled polygon.

    Canvas::fill_rect

    source
    fn Canvas::fill_rect(self : Canvas, x : Double, y : Double, w : Double, h : Double, paint : Paint) -> Unit

    Draw a filled rectangle

    Canvas::fill_rounded_rect

    source
    fn Canvas::fill_rounded_rect(self : Canvas, x : Double, y : Double, w : Double, h : Double, radius : Double, paint : Paint) -> Unit

    Draw a filled rounded rectangle.

    Canvas::fill_rounded_rect_corners

    source
    fn Canvas::fill_rounded_rect_corners(self : Canvas, x : Double, y : Double, w : Double, h : Double, top_left : Double, top_right : Double, bottom_right : Double, bottom_left : Double, paint : Paint) -> Unit

    Draw a filled rounded rectangle with independent corner radii.

    Canvas::get_clip_rect

    source
    fn Canvas::get_clip_rect(self : Canvas) -> Rect?

    Get the current clip rectangle, if any.

    Canvas::get_dirty_region

    source
    fn Canvas::get_dirty_region(self : Canvas) -> DirtyRegion

    Get the accumulated dirty region for incremental rendering.

    Canvas::get_pixmap

    source
    fn Canvas::get_pixmap(self : Canvas) -> Pixmap

    Get the underlying pixmap

    Canvas::get_save_count

    source
    fn Canvas::get_save_count(self : Canvas) -> Int

    Get the number of saved canvas states.

    Canvas::get_transform

    source
    fn Canvas::get_transform(self : Canvas) -> Transform

    Get the current transform

    Canvas::intersect_clip_rect

    source
    fn Canvas::intersect_clip_rect(self : Canvas, rect : Rect) -> Unit

    Intersect the current clip rectangle with a new device-space rectangle.

    Canvas::new

    source
    fn Canvas::new(width : Int, height : Int) -> Canvas

    Create a new canvas with the given dimensions

    Canvas::present_dirty_to

    source
    fn[S : Surface] Canvas::present_dirty_to(self : Canvas, surface : S) -> Result[Int, PresentError]

    Canvas::present_dirty_to_with_limit

    source
    fn[S : Surface] Canvas::present_dirty_to_with_limit(self : Canvas, surface : S, max_rects : Int) -> Result[Int, PresentError]

    Canvas::present_to

    source
    fn[S : Surface] Canvas::present_to(self : Canvas, surface : S) -> Result[Unit, PresentError]

    Canvas::reset_transform

    source
    fn Canvas::reset_transform(self : Canvas) -> Unit

    Reset the current transform to identity.

    Canvas::restore

    source
    fn Canvas::restore(self : Canvas) -> Bool

    Restore the most recently saved transform and clip state.

    Canvas::rotate

    source
    fn Canvas::rotate(self : Canvas, angle : Double) -> Unit

    Rotate subsequent transformed drawing operations by an angle in radians.

    Canvas::save

    source
    fn Canvas::save(self : Canvas) -> Unit

    Save the current transform and clip state.

    Canvas::scale

    source
    fn Canvas::scale(self : Canvas, sx~ : Double, sy~ : Double) -> Unit

    Scale subsequent transformed drawing operations.

    Canvas::set_clip_rect

    source
    fn Canvas::set_clip_rect(self : Canvas, rect : Rect) -> Unit

    Set the current clip rectangle in device coordinates.

    Canvas::set_transform

    source
    fn Canvas::set_transform(self : Canvas, transform : Transform) -> Unit

    Set the current transform

    Canvas::stroke_arc

    source
    fn Canvas::stroke_arc(self : Canvas, cx : Double, cy : Double, radius : Double, start_angle : Double, sweep_angle : Double, paint : Paint) -> Unit

    Draw a stroked circular arc.

    Canvas::stroke_circle

    source
    fn Canvas::stroke_circle(self : Canvas, cx : Double, cy : Double, radius : Double, paint : Paint) -> Unit

    Draw a stroked circle.

    Canvas::stroke_ellipse

    source
    fn Canvas::stroke_ellipse(self : Canvas, cx : Double, cy : Double, rx : Double, ry : Double, paint : Paint) -> Unit

    Draw a stroked ellipse.

    Canvas::stroke_line

    source
    fn Canvas::stroke_line(self : Canvas, x0 : Double, y0 : Double, x1 : Double, y1 : Double, paint : Paint) -> Unit

    Draw a stroked line segment.

    Canvas::stroke_path

    source
    fn Canvas::stroke_path(self : Canvas, path : Path, paint : Paint) -> Unit

    Stroke a path with the given paint

    Canvas::stroke_polygon

    source
    fn Canvas::stroke_polygon(self : Canvas, points : Array[Point], paint : Paint) -> Unit

    Draw a stroked closed polygon.

    Canvas::stroke_polyline

    source
    fn Canvas::stroke_polyline(self : Canvas, points : Array[Point], paint : Paint) -> Unit

    Draw a stroked open polyline.

    Canvas::stroke_rect

    source
    fn Canvas::stroke_rect(self : Canvas, x : Double, y : Double, w : Double, h : Double, paint : Paint) -> Unit

    Draw a stroked rectangle.

    Canvas::stroke_rounded_rect

    source
    fn Canvas::stroke_rounded_rect(self : Canvas, x : Double, y : Double, w : Double, h : Double, radius : Double, paint : Paint) -> Unit

    Draw a stroked rounded rectangle.

    Canvas::stroke_rounded_rect_corners

    source
    fn Canvas::stroke_rounded_rect_corners(self : Canvas, x : Double, y : Double, w : Double, h : Double, top_left : Double, top_right : Double, bottom_right : Double, bottom_left : Double, paint : Paint) -> Unit

    Draw a stroked rounded rectangle with independent corner radii.

    Canvas::to_repr

    source

    Canvas::translate

    source
    fn Canvas::translate(self : Canvas, tx~ : Double, ty~ : Double) -> Unit

    Translate subsequent transformed drawing operations.

    CanvasEdge

    source
    type CanvasEdge derive(
    Debug    )

    CanvasState

    source
    type CanvasState derive(
    Debug    )

    Color

    source
    pub(all) struct Color {
      r : Byte
      g : Byte
      b : Byte
      a : Byte
    } derive(Eq, 
    Debug    )

    RGBA color representation
    impl Show for Color

    Color::black

    source
    fn Color::black() -> Color

    Color::blend_over

    source
    fn Color::blend_over(self : Color, dst : Color) -> Color

    Composite this straight-alpha source color over a destination color

    Color::blend_with

    source
    fn Color::blend_with(self : Color, dst : Color, blend_mode : BlendMode) -> Color

    Composite this straight-alpha source color over a destination color using a configured blend mode.

    Color::blue

    source
    fn Color::blue() -> Color

    Color::equal

    source
    fn Color::equal(Color, Color) -> Bool

    Color::green

    source
    fn Color::green() -> Color

    Color::new

    source
    fn Color::new(r~ : Byte, g~ : Byte, b~ : Byte, a? : Byte) -> Color

    Create a color from RGBA values

    Color::not_equal

    source
    fn Color::not_equal(x : Color, y : Color) -> Bool

    Color::output

    source
    fn Color::output(self : Color, logger : &Logger) -> Unit

    Color::red

    source
    fn Color::red() -> Color

    Color::scale_alpha

    source
    fn Color::scale_alpha(self : Color, opacity : Double) -> Color

    Return this color with its alpha multiplied by opacity

    Color::to_repr

    source

    Color::to_string

    source
    fn Color::to_string(self : Color) -> String

    Color::transparent

    source
    fn Color::transparent() -> Color

    Color::white

    source
    fn Color::white() -> Color

    Predefined colors

    Color::with_alpha

    source
    fn Color::with_alpha(self : Color, alpha : Byte) -> Color

    Return this color with a replaced alpha channel

    DashCursor

    source
    type DashCursor derive(
    Debug    )

    DirtyPresentPlan

    source
    pub struct DirtyPresentPlan {
      mode : DirtyPresentPlanMode
      rects : Array[PixelRect]
    } derive(
    Debug    )

    A concrete dirty-present plan after clipping to the target bounds and applying a rectangle-count limit.

    DirtyPresentPlan::get_mode

    source

    DirtyPresentPlan::get_present_bounds

    source
    fn DirtyPresentPlan::get_present_bounds(self : DirtyPresentPlan) -> PixelRect?

    DirtyPresentPlan::get_present_byte_count

    source
    fn DirtyPresentPlan::get_present_byte_count(self : DirtyPresentPlan) -> Int

    DirtyPresentPlan::get_present_pixel_count

    source
    fn DirtyPresentPlan::get_present_pixel_count(self : DirtyPresentPlan) -> Int

    DirtyPresentPlan::get_present_strategy

    source
    fn DirtyPresentPlan::get_present_strategy(self : DirtyPresentPlan, width : Int, height : Int) -> DirtyPresentStrategy

    DirtyPresentPlan::get_rect_count

    source
    fn DirtyPresentPlan::get_rect_count(self : DirtyPresentPlan) -> Int

    DirtyPresentPlan::get_rects

    source

    DirtyPresentPlan::is_empty

    source
    fn DirtyPresentPlan::is_empty(self : DirtyPresentPlan) -> Bool

    DirtyPresentPlan::saves_full_present_pixels

    source
    fn DirtyPresentPlan::saves_full_present_pixels(self : DirtyPresentPlan, width : Int, height : Int) -> Bool

    DirtyPresentPlan::to_repr

    source

    DirtyPresentPlan::uses_bounds_fallback

    source
    fn DirtyPresentPlan::uses_bounds_fallback(self : DirtyPresentPlan) -> Bool

    DirtyPresentPlanMode

    source
    pub(all) enum DirtyPresentPlanMode {
      Empty
      Rects
      Bounds
    } derive(Eq, 
    Debug    )

    Strategy selected for submitting a dirty region to a Surface.

    DirtyPresentPlanMode::equal

    source

    DirtyPresentPlanMode::not_equal

    source

    DirtyPresentPlanMode::to_repr

    source

    DirtyPresentStrategy

    source
    pub(all) enum DirtyPresentStrategy {
      Skip
      Partial
      Full
    } derive(Eq, 
    Debug    )

    Scheduler-facing present strategy chosen from a dirty present plan and the full-frame pixel budget.

    DirtyPresentStrategy::equal

    source

    DirtyPresentStrategy::not_equal

    source

    DirtyPresentStrategy::to_repr

    source

    DirtyRegion

    source
    pub struct DirtyRegion {
      rects : Array[PixelRect]
    } derive(
    Debug    )

    Accumulates pixel-aligned dirty rectangles for incremental rendering.

    DirtyRegion::add_all

    source
    fn DirtyRegion::add_all(self : DirtyRegion, width : Int, height : Int) -> Unit

    DirtyRegion::add_clipped_rect

    source
    fn DirtyRegion::add_clipped_rect(self : DirtyRegion, rect : PixelRect, bounds : PixelRect) -> Unit

    DirtyRegion::add_rect

    source
    fn DirtyRegion::add_rect(self : DirtyRegion, rect : PixelRect) -> Unit

    DirtyRegion::bounds

    source
    fn DirtyRegion::bounds(self : DirtyRegion) -> PixelRect?

    DirtyRegion::clear

    source
    fn DirtyRegion::clear(self : DirtyRegion) -> Unit

    DirtyRegion::get_rect_count

    source
    fn DirtyRegion::get_rect_count(self : DirtyRegion) -> Int

    DirtyRegion::get_rects

    source
    fn DirtyRegion::get_rects(self : DirtyRegion) -> Array[PixelRect]

    DirtyRegion::is_empty

    source
    fn DirtyRegion::is_empty(self : DirtyRegion) -> Bool

    DirtyRegion::new

    source

    DirtyRegion::present_plan

    source
    fn DirtyRegion::present_plan(self : DirtyRegion, bounds : PixelRect, max_rects : Int) -> DirtyPresentPlan

    DirtyRegion::present_rects

    source
    fn DirtyRegion::present_rects(self : DirtyRegion, bounds : PixelRect, max_rects : Int) -> Array[PixelRect]

    DirtyRegion::to_repr

    source

    DirtySubmitPlan

    source
    pub struct DirtySubmitPlan {
      dirty_bounds : PixelRect?
      present_plan : DirtyPresentPlan
    } derive(
    Debug    )

    Dirty state snapshot for schedulers: logical dirty bounds plus the clipped present plan that would be submitted to the current surface.

    DirtySubmitPlan::get_dirty_bounds

    source
    fn DirtySubmitPlan::get_dirty_bounds(self : DirtySubmitPlan) -> PixelRect?

    DirtySubmitPlan::get_present_bounds

    source
    fn DirtySubmitPlan::get_present_bounds(self : DirtySubmitPlan) -> PixelRect?

    DirtySubmitPlan::get_present_byte_count

    source
    fn DirtySubmitPlan::get_present_byte_count(self : DirtySubmitPlan) -> Int

    DirtySubmitPlan::get_present_pixel_count

    source
    fn DirtySubmitPlan::get_present_pixel_count(self : DirtySubmitPlan) -> Int

    DirtySubmitPlan::get_present_plan

    source
    fn DirtySubmitPlan::get_present_plan(self : DirtySubmitPlan) -> DirtyPresentPlan

    DirtySubmitPlan::get_present_rect_count

    source
    fn DirtySubmitPlan::get_present_rect_count(self : DirtySubmitPlan) -> Int

    DirtySubmitPlan::get_present_strategy

    source
    fn DirtySubmitPlan::get_present_strategy(self : DirtySubmitPlan, width : Int, height : Int) -> DirtyPresentStrategy

    DirtySubmitPlan::get_state

    source

    DirtySubmitPlan::has_dirty

    source
    fn DirtySubmitPlan::has_dirty(self : DirtySubmitPlan) -> Bool

    DirtySubmitPlan::needs_present

    source
    fn DirtySubmitPlan::needs_present(self : DirtySubmitPlan) -> Bool

    DirtySubmitPlan::saves_full_present_pixels

    source
    fn DirtySubmitPlan::saves_full_present_pixels(self : DirtySubmitPlan, width : Int, height : Int) -> Bool

    DirtySubmitPlan::to_repr

    source

    DirtySubmitPlan::uses_bounds_fallback

    source
    fn DirtySubmitPlan::uses_bounds_fallback(self : DirtySubmitPlan) -> Bool

    DirtySubmitResult

    source
    pub struct DirtySubmitResult {
      submit_plan : DirtySubmitPlan
      presented_rect_count : Int
    } derive(
    Debug    )

    Result of submitting a dirty frame: the scheduler-visible plan snapshot plus the number of rectangles actually presented to the surface.

    DirtySubmitResult::did_present

    source
    fn DirtySubmitResult::did_present(self : DirtySubmitResult) -> Bool

    DirtySubmitResult::get_dirty_bounds

    source
    fn DirtySubmitResult::get_dirty_bounds(self : DirtySubmitResult) -> PixelRect?

    DirtySubmitResult::get_present_bounds

    source
    fn DirtySubmitResult::get_present_bounds(self : DirtySubmitResult) -> PixelRect?

    DirtySubmitResult::get_present_byte_count

    source
    fn DirtySubmitResult::get_present_byte_count(self : DirtySubmitResult) -> Int

    DirtySubmitResult::get_present_pixel_count

    source
    fn DirtySubmitResult::get_present_pixel_count(self : DirtySubmitResult) -> Int

    DirtySubmitResult::get_present_strategy

    source
    fn DirtySubmitResult::get_present_strategy(self : DirtySubmitResult, width : Int, height : Int) -> DirtyPresentStrategy

    DirtySubmitResult::get_presented_rect_count

    source
    fn DirtySubmitResult::get_presented_rect_count(self : DirtySubmitResult) -> Int

    DirtySubmitResult::get_state

    source

    DirtySubmitResult::get_submit_plan

    source
    fn DirtySubmitResult::get_submit_plan(self : DirtySubmitResult) -> DirtySubmitPlan

    DirtySubmitResult::has_dirty

    source
    fn DirtySubmitResult::has_dirty(self : DirtySubmitResult) -> Bool

    DirtySubmitResult::needs_present

    source
    fn DirtySubmitResult::needs_present(self : DirtySubmitResult) -> Bool

    DirtySubmitResult::saves_full_present_pixels

    source
    fn DirtySubmitResult::saves_full_present_pixels(self : DirtySubmitResult, width : Int, height : Int) -> Bool

    DirtySubmitResult::to_repr

    source

    DirtySubmitResult::uses_bounds_fallback

    source
    fn DirtySubmitResult::uses_bounds_fallback(self : DirtySubmitResult) -> Bool

    DirtySubmitResult::was_clipped_away

    source
    fn DirtySubmitResult::was_clipped_away(self : DirtySubmitResult) -> Bool

    DirtySubmitState

    source
    pub(all) enum DirtySubmitState {
      Clean
      Present
      DirtyClippedAway
    } derive(Eq, 
    Debug    )

    Scheduler-facing state for a dirty submit snapshot.

    DirtySubmitState::equal

    source

    DirtySubmitState::not_equal

    source
    fn DirtySubmitState::not_equal(x : DirtySubmitState, y : DirtySubmitState) -> Bool

    DirtySubmitState::to_repr

    source

    FillRule

    source
    pub(all) enum FillRule {
      NonZero
      EvenOdd
    } derive(Eq, 
    Debug    )

    Fill rule for path filling

    FillRule::equal

    source
    fn FillRule::equal(FillRule, FillRule) -> Bool

    FillRule::not_equal

    source
    fn FillRule::not_equal(x : FillRule, y : FillRule) -> Bool

    FillRule::to_repr

    source

    ImageQuality

    source
    pub(all) enum ImageQuality {
      Fast
      Balanced
      High
    } derive(Eq, 
    Debug    )

    Image quality strategy for callers that prefer intent over a concrete sampling algorithm.

    ImageQuality::equal

    source

    ImageQuality::not_equal

    source
    fn ImageQuality::not_equal(x : ImageQuality, y : ImageQuality) -> Bool

    ImageQuality::to_repr

    source

    ImageQuality::to_sampling

    source
    fn ImageQuality::to_sampling(self : ImageQuality) -> ImageSampling

    Return the concrete sampling mode selected by this quality strategy.

    ImageSampling

    source
    pub(all) enum ImageSampling {
      Nearest
      Bilinear
      Bicubic
    } derive(Eq, 
    Debug    )

    Sampling mode used when scaling source pixmaps.

    ImageSampling::equal

    source

    ImageSampling::not_equal

    source
    fn ImageSampling::not_equal(x : ImageSampling, y : ImageSampling) -> Bool

    ImageSampling::to_repr

    source

    Layer

    source
    pub struct Layer {
      canvas : Canvas
      x : Int
      y : Int
      visible : Bool
      opacity : Double
      blend_mode : BlendMode
      shader : PaintShader?
      filter : PaintFilter?
    } derive(
    Debug    )

    Off-screen drawing cache backed by a Canvas. Layers are intended for GUI subtrees that can redraw locally and then composite their dirty pixels into a parent canvas.

    Layer::bounds

    source
    fn Layer::bounds(self : Layer) -> PixelRect

    Layer::clear

    source
    fn Layer::clear(self : Layer, color : Color) -> Unit

    Layer::clear_dirty_region

    source
    fn Layer::clear_dirty_region(self : Layer) -> Unit

    Layer::clear_filter

    source
    fn Layer::clear_filter(self : Layer) -> Layer

    Layer::clear_shader

    source
    fn Layer::clear_shader(self : Layer) -> Layer

    Layer::composite_dirty_to

    source
    fn Layer::composite_dirty_to(self : Layer, target : Canvas, max_rects : Int) -> Int

    Layer::composite_dirty_to_result

    source
    fn Layer::composite_dirty_to_result(self : Layer, target : Canvas, max_rects : Int) -> LayerCompositeResult

    Composite dirty cache pixels and return lifecycle telemetry.

    Layer::composite_to

    source
    fn Layer::composite_to(self : Layer, target : Canvas) -> Int

    Layer::dirty_bounds

    source
    fn Layer::dirty_bounds(self : Layer) -> PixelRect?

    Layer::get_blend_mode

    source
    fn Layer::get_blend_mode(self : Layer) -> BlendMode

    Layer::get_canvas

    source
    fn Layer::get_canvas(self : Layer) -> Canvas

    Layer::get_dirty_region

    source
    fn Layer::get_dirty_region(self : Layer) -> DirtyRegion

    Layer::get_filter

    source
    fn Layer::get_filter(self : Layer) -> PaintFilter?

    Layer::get_height

    source
    fn Layer::get_height(self : Layer) -> Int

    Layer::get_opacity

    source
    fn Layer::get_opacity(self : Layer) -> Double

    Layer::get_pixmap

    source
    fn Layer::get_pixmap(self : Layer) -> Pixmap

    Layer::get_shader

    source
    fn Layer::get_shader(self : Layer) -> PaintShader?

    Layer::get_width

    source
    fn Layer::get_width(self : Layer) -> Int

    Layer::get_x

    source
    fn Layer::get_x(self : Layer) -> Int

    Layer::get_y

    source
    fn Layer::get_y(self : Layer) -> Int

    Layer::has_dirty

    source
    fn Layer::has_dirty(self : Layer) -> Bool

    Layer::is_compositable

    source
    fn Layer::is_compositable(self : Layer) -> Bool

    Layer::is_visible

    source
    fn Layer::is_visible(self : Layer) -> Bool

    Layer::mark_all_dirty

    source
    fn Layer::mark_all_dirty(self : Layer) -> Unit

    Layer::mark_dirty_rect

    source
    fn Layer::mark_dirty_rect(self : Layer, rect : PixelRect) -> Unit

    Layer::new

    source
    fn Layer::new(width : Int, height : Int) -> Layer

    Layer::resize

    source
    fn Layer::resize(self : Layer, width : Int, height : Int) -> Layer

    Layer::set_blend_mode

    source
    fn Layer::set_blend_mode(self : Layer, blend_mode : BlendMode) -> Layer

    Layer::set_filter

    source
    fn Layer::set_filter(self : Layer, filter : PaintFilter) -> Layer

    Layer::set_opacity

    source
    fn Layer::set_opacity(self : Layer, opacity : Double) -> Layer

    Layer::set_position

    source
    fn Layer::set_position(self : Layer, x : Int, y : Int) -> Layer

    Layer::set_shader

    source
    fn Layer::set_shader(self : Layer, shader : PaintShader) -> Layer

    Set the shader used when compositing this layer. The shader is sampled in layer-local coordinates so moving a layer preserves its cached pattern.

    Layer::set_visible

    source
    fn Layer::set_visible(self : Layer, visible : Bool) -> Layer

    Layer::to_repr

    source

    Layer::translated_bounds

    source
    fn Layer::translated_bounds(self : Layer) -> PixelRect

    Layer::translated_dirty_bounds

    source
    fn Layer::translated_dirty_bounds(self : Layer) -> PixelRect?

    Layer::translated_dirty_rects

    source
    fn Layer::translated_dirty_rects(self : Layer, max_rects : Int) -> Array[PixelRect]

    LayerCompositeResult

    source
    pub struct LayerCompositeResult {
      composited_rect_count : Int
      local_dirty_bounds : PixelRect?
      target_dirty_bounds : PixelRect?
      uses_bounds_fallback : Bool
      did_composite : Bool
      did_clear_dirty : Bool
    } derive(
    Debug    )

    Telemetry for a dirty layer composite attempt.

    LayerCompositeResult::did_clear_dirty

    source
    fn LayerCompositeResult::did_clear_dirty(self : LayerCompositeResult) -> Bool

    Return whether the layer dirty region was cleared after compositing.

    LayerCompositeResult::did_composite

    source
    fn LayerCompositeResult::did_composite(self : LayerCompositeResult) -> Bool

    Return whether any dirty pixels were composited into the target.

    LayerCompositeResult::get_composited_rect_count

    source
    fn LayerCompositeResult::get_composited_rect_count(self : LayerCompositeResult) -> Int

    Return the number of dirty rectangles composited into the target.

    LayerCompositeResult::get_local_dirty_bounds

    source
    fn LayerCompositeResult::get_local_dirty_bounds(self : LayerCompositeResult) -> PixelRect?

    Return the layer-local bounds covered by this composite attempt.

    LayerCompositeResult::get_target_dirty_bounds

    source
    fn LayerCompositeResult::get_target_dirty_bounds(self : LayerCompositeResult) -> PixelRect?

    Return the target-space bounds covered by this composite attempt.

    LayerCompositeResult::to_repr

    source

    LayerCompositeResult::uses_bounds_fallback

    source
    fn LayerCompositeResult::uses_bounds_fallback(self : LayerCompositeResult) -> Bool

    Return whether dirty composition fell back to the dirty bounds rectangle because the candidate dirty rect count exceeded the requested limit.

    LayerTree

    source
    pub struct LayerTree {
      layers : Array[Layer]
      invalidation : DirtyRegion
    } derive(
    Debug    )

    Ordered collection of cached layers. Layers added later are composited above earlier layers.

    LayerTree::add_layer

    source
    fn LayerTree::add_layer(self : LayerTree, layer : Layer) -> Int

    LayerTree::clear_dirty_regions

    source
    fn LayerTree::clear_dirty_regions(self : LayerTree) -> Unit

    LayerTree::clear_layer_filter

    source
    fn LayerTree::clear_layer_filter(self : LayerTree, index : Int) -> Bool

    LayerTree::clear_layer_shader

    source
    fn LayerTree::clear_layer_shader(self : LayerTree, index : Int) -> Bool

    LayerTree::composite_dirty_to

    source
    fn LayerTree::composite_dirty_to(self : LayerTree, target : Canvas, max_rects : Int) -> Int

    LayerTree::composite_to

    source
    fn LayerTree::composite_to(self : LayerTree, target : Canvas) -> Int

    LayerTree::dirty_bounds

    source
    fn LayerTree::dirty_bounds(self : LayerTree) -> PixelRect?

    LayerTree::dirty_present_batch

    source
    fn[S : Surface] LayerTree::dirty_present_batch(self : LayerTree, target : Canvas, surface : S, max_rects : Int) -> Result[PresentBatch, PresentError]

    LayerTree::dirty_present_plan

    source
    fn[S : Surface] LayerTree::dirty_present_plan(self : LayerTree, target : Canvas, surface : S, max_rects : Int) -> DirtyPresentPlan

    LayerTree::dirty_rects

    source
    fn LayerTree::dirty_rects(self : LayerTree, max_rects : Int) -> Array[PixelRect]

    LayerTree::dirty_submit_plan

    source
    fn[S : Surface] LayerTree::dirty_submit_plan(self : LayerTree, target : Canvas, surface : S, max_rects : Int) -> DirtySubmitPlan

    LayerTree::get_compositable_layer_count

    source
    fn LayerTree::get_compositable_layer_count(self : LayerTree) -> Int

    LayerTree::get_layer

    source
    fn LayerTree::get_layer(self : LayerTree, index : Int) -> Layer?

    LayerTree::get_layer_count

    source
    fn LayerTree::get_layer_count(self : LayerTree) -> Int

    LayerTree::invalidate_layer

    source
    fn LayerTree::invalidate_layer(self : LayerTree, index : Int) -> Bool

    LayerTree::invalidate_rect

    source
    fn LayerTree::invalidate_rect(self : LayerTree, rect : PixelRect) -> Unit

    LayerTree::new

    source
    fn LayerTree::new() -> LayerTree

    LayerTree::present_all_to

    source
    fn[S : Surface] LayerTree::present_all_to(self : LayerTree, target : Canvas, surface : S) -> Result[Int, PresentError]

    LayerTree::present_all_to_with_limit

    source
    fn[S : Surface] LayerTree::present_all_to_with_limit(self : LayerTree, target : Canvas, surface : S, max_rects : Int) -> Result[Int, PresentError]

    LayerTree::present_dirty_to

    source
    fn[S : Surface] LayerTree::present_dirty_to(self : LayerTree, target : Canvas, surface : S) -> Result[Int, PresentError]

    LayerTree::present_dirty_to_with_limit

    source
    fn[S : Surface] LayerTree::present_dirty_to_with_limit(self : LayerTree, target : Canvas, surface : S, max_rects : Int) -> Result[Int, PresentError]

    LayerTree::redraw_schedule

    source
    fn[S : Surface] LayerTree::redraw_schedule(self : LayerTree, target : Canvas, surface : S, max_rects : Int) -> RenderFrameSchedule

    LayerTree::remove_layer

    source
    fn LayerTree::remove_layer(self : LayerTree, index : Int) -> Layer?

    LayerTree::reorder_layer

    source
    fn LayerTree::reorder_layer(self : LayerTree, from_index : Int, to_index : Int) -> Bool

    LayerTree::replace_layer

    source
    fn LayerTree::replace_layer(self : LayerTree, index : Int, layer : Layer) -> Layer?

    LayerTree::resize_layer

    source
    fn LayerTree::resize_layer(self : LayerTree, index : Int, width : Int, height : Int) -> Bool

    LayerTree::set_layer_blend_mode

    source
    fn LayerTree::set_layer_blend_mode(self : LayerTree, index : Int, blend_mode : BlendMode) -> Bool

    LayerTree::set_layer_filter

    source
    fn LayerTree::set_layer_filter(self : LayerTree, index : Int, filter : PaintFilter) -> Bool

    LayerTree::set_layer_opacity

    source
    fn LayerTree::set_layer_opacity(self : LayerTree, index : Int, opacity : Double) -> Bool

    LayerTree::set_layer_position

    source
    fn LayerTree::set_layer_position(self : LayerTree, index : Int, x : Int, y : Int) -> Bool

    LayerTree::set_layer_shader

    source
    fn LayerTree::set_layer_shader(self : LayerTree, index : Int, shader : PaintShader) -> Bool

    Set the shader used when compositing a layer. The shader is sampled in the layer's local coordinates so layer movement does not shift the pattern.

    LayerTree::set_layer_visible

    source
    fn LayerTree::set_layer_visible(self : LayerTree, index : Int, visible : Bool) -> Bool

    LayerTree::submit_by_strategy_plan

    source
    fn[S : Surface] LayerTree::submit_by_strategy_plan(self : LayerTree, target : Canvas, surface : S, max_rects : Int) -> RenderFrameSubmitPlan

    LayerTree::submit_dirty_to

    source
    fn[S : Surface] LayerTree::submit_dirty_to(self : LayerTree, target : Canvas, surface : S) -> Result[DirtySubmitResult, PresentError]

    LayerTree::submit_dirty_to_with_limit

    source
    fn[S : Surface] LayerTree::submit_dirty_to_with_limit(self : LayerTree, target : Canvas, surface : S, max_rects : Int) -> Result[DirtySubmitResult, PresentError]

    LayerTree::submit_request_by_policy

    source
    fn[S : Surface] LayerTree::submit_request_by_policy(self : LayerTree, target : Canvas, surface : S, max_rects : Int, policy : RenderFrameSubmitPolicy) -> RenderFrameSubmitRequest

    LayerTree::submit_request_to

    source
    fn[S : Surface] LayerTree::submit_request_to(self : LayerTree, target : Canvas, surface : S, request : RenderFrameSubmitRequest) -> Result[RenderFrameSubmitResult, PresentError]

    LayerTree::submit_request_to_with_limit

    source
    fn[S : Surface] LayerTree::submit_request_to_with_limit(self : LayerTree, target : Canvas, surface : S, max_rects : Int, request : RenderFrameSubmitRequest) -> Result[RenderFrameSubmitResult, PresentError]

    LayerTree::submit_schedule

    source
    fn[S : Surface] LayerTree::submit_schedule(self : LayerTree, target : Canvas, surface : S, max_rects : Int) -> RenderFrameSchedule

    LayerTree::submit_schedule_by_policy

    source
    fn[S : Surface] LayerTree::submit_schedule_by_policy(self : LayerTree, target : Canvas, surface : S, max_rects : Int, policy : RenderFrameSubmitPolicy) -> RenderFrameSchedule

    LayerTree::submit_scheduled_to

    source
    fn[S : Surface] LayerTree::submit_scheduled_to(self : LayerTree, target : Canvas, surface : S, schedule : RenderFrameSchedule) -> Result[RenderFrameSubmitResult, PresentError]

    LayerTree::submit_scheduled_to_with_limit

    source
    fn[S : Surface] LayerTree::submit_scheduled_to_with_limit(self : LayerTree, target : Canvas, surface : S, max_rects : Int, schedule : RenderFrameSchedule) -> Result[RenderFrameSubmitResult, PresentError]

    LayerTree::submit_to_by_policy

    source
    fn[S : Surface] LayerTree::submit_to_by_policy(self : LayerTree, target : Canvas, surface : S, policy : RenderFrameSubmitPolicy) -> Result[RenderFrameSubmitResult, PresentError]

    LayerTree::submit_to_by_policy_with_limit

    source
    fn[S : Surface] LayerTree::submit_to_by_policy_with_limit(self : LayerTree, target : Canvas, surface : S, max_rects : Int, policy : RenderFrameSubmitPolicy) -> Result[RenderFrameSubmitResult, PresentError]

    LayerTree::to_repr

    source

    MemoryPresentRecord

    source
    pub struct MemoryPresentRecord {
      rect : PixelRect
      row_bytes : Int
    } derive(Eq, 
    Debug    )

    One validated present operation recorded by MemorySurface.

    MemoryPresentRecord::equal

    source

    MemoryPresentRecord::get_present_byte_count

    source
    fn MemoryPresentRecord::get_present_byte_count(self : MemoryPresentRecord) -> Int

    MemoryPresentRecord::get_present_pixel_count

    source
    fn MemoryPresentRecord::get_present_pixel_count(self : MemoryPresentRecord) -> Int

    MemoryPresentRecord::get_rect

    source

    MemoryPresentRecord::get_row_bytes

    source
    fn MemoryPresentRecord::get_row_bytes(self : MemoryPresentRecord) -> Int

    MemoryPresentRecord::get_source_byte_count

    source
    fn MemoryPresentRecord::get_source_byte_count(self : MemoryPresentRecord) -> Int

    MemoryPresentRecord::get_source_padding_byte_count

    source
    fn MemoryPresentRecord::get_source_padding_byte_count(self : MemoryPresentRecord) -> Int

    MemoryPresentRecord::not_equal

    source

    MemoryPresentRecord::to_repr

    source

    MemorySurface

    source
    pub struct MemorySurface {
      width : Int
      height : Int
      pixels : FixedArray[Byte]
      present_count : Int
      present_records : Array[MemoryPresentRecord]
    } derive(
    Debug    )

    In-memory surface used as the reference backend for tests and headless tools.

    MemorySurface::checksum

    source
    fn MemorySurface::checksum(self : MemorySurface) -> Int

    Return a deterministic lightweight checksum of the current surface pixels.

    MemorySurface::checksum_rect

    source
    fn MemorySurface::checksum_rect(self : MemorySurface, rect : PixelRect) -> Result[Int, PresentError]

    Return a deterministic lightweight checksum of a surface rectangle.

    MemorySurface::get_height

    source
    fn MemorySurface::get_height(self : MemorySurface) -> Int

    MemorySurface::get_last_present_record

    source
    fn MemorySurface::get_last_present_record(self : MemorySurface) -> MemoryPresentRecord?

    MemorySurface::get_pixel

    source
    fn MemorySurface::get_pixel(self : MemorySurface, x : Int, y : Int) -> Color

    MemorySurface::get_pixels

    source
    fn MemorySurface::get_pixels(self : MemorySurface) -> FixedArray[Byte]

    Return a copied snapshot of the surface's RGBA pixels.

    MemorySurface::get_present_bounds

    source
    fn MemorySurface::get_present_bounds(self : MemorySurface) -> PixelRect?

    MemorySurface::get_present_byte_count

    source
    fn MemorySurface::get_present_byte_count(self : MemorySurface) -> Int

    MemorySurface::get_present_count

    source
    fn MemorySurface::get_present_count(self : MemorySurface) -> Int

    MemorySurface::get_present_pixel_count

    source
    fn MemorySurface::get_present_pixel_count(self : MemorySurface) -> Int

    MemorySurface::get_present_records

    source
    fn MemorySurface::get_present_records(self : MemorySurface) -> Array[MemoryPresentRecord]

    MemorySurface::get_present_source_byte_count

    source
    fn MemorySurface::get_present_source_byte_count(self : MemorySurface) -> Int

    MemorySurface::get_present_source_padding_byte_count

    source
    fn MemorySurface::get_present_source_padding_byte_count(self : MemorySurface) -> Int

    MemorySurface::get_width

    source
    fn MemorySurface::get_width(self : MemorySurface) -> Int

    MemorySurface::new

    source
    fn MemorySurface::new(width : Int, height : Int) -> MemorySurface

    MemorySurface::present_pixels

    source
    fn MemorySurface::present_pixels(self : MemorySurface, width : Int, height : Int, row_bytes : Int, pixels : FixedArray[Byte]) -> Result[Unit, PresentError]

    MemorySurface::present_pixels_rect

    source
    fn MemorySurface::present_pixels_rect(self : MemorySurface, x : Int, y : Int, width : Int, height : Int, row_bytes : Int, pixels : FixedArray[Byte]) -> Result[Unit, PresentError]

    MemorySurface::reset_present_telemetry

    source
    fn MemorySurface::reset_present_telemetry(self : MemorySurface) -> Unit

    Clear accumulated present telemetry while preserving surface pixels.

    MemorySurface::to_bmp_bytes

    source
    fn MemorySurface::to_bmp_bytes(self : MemorySurface) -> Bytes

    Encode the current surface pixels as deterministic 32-bit BMP(BGRA) bytes.

    MemorySurface::to_bmp_rect_bytes

    source
    fn MemorySurface::to_bmp_rect_bytes(self : MemorySurface, rect : PixelRect) -> Result[Bytes, PresentError]

    Encode a rectangle of this surface as deterministic 32-bit BMP(BGRA) bytes.

    MemorySurface::to_pixmap

    source
    fn MemorySurface::to_pixmap(self : MemorySurface) -> Pixmap

    Snapshot this in-memory surface into an isolated pixmap.

    MemorySurface::to_pixmap_rect

    source
    fn MemorySurface::to_pixmap_rect(self : MemorySurface, rect : PixelRect) -> Result[Pixmap, PresentError]

    Snapshot a rectangle of this in-memory surface into an isolated pixmap.

    MemorySurface::to_png_bytes

    source
    fn MemorySurface::to_png_bytes(self : MemorySurface) -> Result[Bytes, PixmapEncodeError]

    Encode the current surface pixels as deterministic 8-bit RGBA PNG bytes.

    MemorySurface::to_png_rect_bytes

    source
    fn MemorySurface::to_png_rect_bytes(self : MemorySurface, rect : PixelRect) -> Result[Bytes, PresentError]

    Encode a rectangle of this surface as deterministic 8-bit RGBA PNG bytes.

    MemorySurface::to_ppm_bytes

    source
    fn MemorySurface::to_ppm_bytes(self : MemorySurface) -> Bytes

    Encode the current surface pixels as deterministic binary PPM(P6) bytes.

    MemorySurface::to_ppm_rect_bytes

    source
    fn MemorySurface::to_ppm_rect_bytes(self : MemorySurface, rect : PixelRect) -> Result[Bytes, PresentError]

    Encode a rectangle of this surface as deterministic binary PPM(P6) bytes.

    MemorySurface::to_repr

    source

    MemorySurface::to_rgba_bytes

    source
    fn MemorySurface::to_rgba_bytes(self : MemorySurface) -> Bytes

    Return an isolated copy of the current surface RGBA pixel bytes.

    MemorySurface::to_rgba_rect_bytes

    source
    fn MemorySurface::to_rgba_rect_bytes(self : MemorySurface, rect : PixelRect) -> Result[Bytes, PresentError]

    Return packed RGBA bytes for a surface rectangle in row-major order.

    NinePatchInsets

    source
    pub struct NinePatchInsets {
      left : Int
      top : Int
      right : Int
      bottom : Int
    } derive(Eq, 
    Debug    )

    Insets used for nine-patch image scaling.

    NinePatchInsets::equal

    source

    NinePatchInsets::new

    source
    fn NinePatchInsets::new(left~ : Int, top~ : Int, right~ : Int, bottom~ : Int) -> NinePatchInsets

    NinePatchInsets::not_equal

    source
    fn NinePatchInsets::not_equal(x : NinePatchInsets, y : NinePatchInsets) -> Bool

    NinePatchInsets::to_repr

    source

    NinePatchSlices

    source
    type NinePatchSlices derive(
    Debug    )

    Paint

    source
    pub struct Paint {
      color : Color
      shader : PaintShader?
      filter : PaintFilter?
      style : PaintStyle
      blend_mode : BlendMode
      stroke_width : Double
      stroke_cap : StrokeCap
      stroke_join : StrokeJoin
      miter_limit : Double
      stroke_dash_pattern : Array[Double]
      stroke_dash_offset : Double
      fill_rule : FillRule
      opacity : Double
    } derive(
    Debug    )

    Paint configuration for drawing operations

    Paint::clear_filter

    source
    fn Paint::clear_filter(self : Paint) -> Paint

    Clear the active color filter.

    Paint::clear_shader

    source
    fn Paint::clear_shader(self : Paint) -> Paint

    Clear shader color source and return to solid-color drawing.

    Paint::clear_stroke_dash

    source
    fn Paint::clear_stroke_dash(self : Paint) -> Paint

    Clear stroke dash pattern and return to solid strokes.

    Paint::get_blend_mode

    source
    fn Paint::get_blend_mode(self : Paint) -> BlendMode

    Return the pixel blend mode used when compositing this paint.

    Paint::get_color

    source
    fn Paint::get_color(self : Paint) -> Color

    Return the solid paint color used when no shader color source is active.

    Paint::get_fill_rule

    source
    fn Paint::get_fill_rule(self : Paint) -> FillRule

    Return the fill rule used by path filling.

    Paint::get_filter

    source
    fn Paint::get_filter(self : Paint) -> PaintFilter?

    Return the configured color filter, if any.

    Paint::get_miter_limit

    source
    fn Paint::get_miter_limit(self : Paint) -> Double

    Return the stroke miter limit.

    Paint::get_opacity

    source
    fn Paint::get_opacity(self : Paint) -> Double

    Return the normalized configured opacity.

    Paint::get_shader

    source
    fn Paint::get_shader(self : Paint) -> PaintShader?

    Return the configured shader color source, if any.

    Paint::get_stroke_cap

    source
    fn Paint::get_stroke_cap(self : Paint) -> StrokeCap

    Return the stroke cap style.

    Paint::get_stroke_dash_offset

    source
    fn Paint::get_stroke_dash_offset(self : Paint) -> Double

    Return the stroke dash phase offset.

    Paint::get_stroke_dash_pattern

    source
    fn Paint::get_stroke_dash_pattern(self : Paint) -> Array[Double]

    Return a copied normalized stroke dash pattern.

    Paint::get_stroke_join

    source
    fn Paint::get_stroke_join(self : Paint) -> StrokeJoin

    Return the stroke join style.

    Paint::get_stroke_width

    source
    fn Paint::get_stroke_width(self : Paint) -> Double

    Return the stroke width.

    Paint::get_style

    source
    fn Paint::get_style(self : Paint) -> PaintStyle

    Return the paint style.

    Paint::has_filter

    source
    fn Paint::has_filter(self : Paint) -> Bool

    Return whether this paint has an active color filter.

    Paint::has_shader

    source
    fn Paint::has_shader(self : Paint) -> Bool

    Return whether this paint has an active shader color source.

    Paint::has_stroke_dash

    source
    fn Paint::has_stroke_dash(self : Paint) -> Bool

    Return whether this paint has a normalized stroke dash pattern.

    Paint::new

    source
    fn Paint::new() -> Paint

    Create a default paint

    Paint::sample_color

    source
    fn Paint::sample_color(self : Paint, x : Double, y : Double) -> Color

    Sample this paint's active color source at a device-space point and apply paint opacity.

    Paint::sample_source_color

    source
    fn Paint::sample_source_color(self : Paint, color : Color) -> Color

    Apply this paint's filter and opacity to a sampled source pixel.

    Paint::set_blend_mode

    source
    fn Paint::set_blend_mode(self : Paint, blend_mode : BlendMode) -> Paint

    Set pixel blend mode used when compositing this paint.

    Paint::set_color

    source
    fn Paint::set_color(self : Paint, color : Color) -> Paint

    Set the paint color and clear any shader color source.

    Paint::set_dotted_stroke

    source
    fn Paint::set_dotted_stroke(self : Paint) -> Paint

    Configure a round dotted stroke using the current stroke width.

    Paint::set_fill_rule

    source
    fn Paint::set_fill_rule(self : Paint, fill_rule : FillRule) -> Paint

    Set fill rule

    Paint::set_filter

    source
    fn Paint::set_filter(self : Paint, filter : PaintFilter) -> Paint

    Set a color filter applied after color sampling and before opacity.

    Paint::set_miter_limit

    source
    fn Paint::set_miter_limit(self : Paint, limit : Double) -> Paint

    Set stroke miter limit. Values below 1.0 are clamped to the minimum meaningful ratio.

    Paint::set_opacity

    source
    fn Paint::set_opacity(self : Paint, opacity : Double) -> Paint

    Set opacity (0.0 to 1.0)

    Paint::set_shader

    source
    fn Paint::set_shader(self : Paint, shader : PaintShader) -> Paint

    Set a shader color source for vector and mask drawing.

    Paint::set_stroke_cap

    source
    fn Paint::set_stroke_cap(self : Paint, cap : StrokeCap) -> Paint

    Set stroke cap style

    Paint::set_stroke_dash

    source
    fn Paint::set_stroke_dash(self : Paint, pattern : Array[Double], offset : Double) -> Paint

    Set stroke dash pattern and phase offset. Empty or non-positive-only patterns draw a solid stroke.

    Paint::set_stroke_join

    source
    fn Paint::set_stroke_join(self : Paint, join : StrokeJoin) -> Paint

    Set stroke join style

    Paint::set_stroke_width

    source
    fn Paint::set_stroke_width(self : Paint, width : Double) -> Paint

    Set stroke width

    Paint::set_style

    source
    fn Paint::set_style(self : Paint, style : PaintStyle) -> Paint

    Set the paint style

    Paint::to_repr

    source

    PaintFilter

    source
    type PaintFilter derive(Eq, 
    Debug    )

    Paint color filter applied after color sampling and before opacity.

    PaintFilter::apply

    source
    fn PaintFilter::apply(self : PaintFilter, color : Color) -> Color

    Apply this filter to a straight-alpha color.

    PaintFilter::brightness

    source
    fn PaintFilter::brightness(factor : Double) -> PaintFilter

    Create a filter that scales RGB brightness and preserves alpha.

    PaintFilter::color_matrix

    source
    fn PaintFilter::color_matrix(values : Array[Double]) -> PaintFilter

    Create a filter from a 4x5 RGBA color matrix.

    PaintFilter::compose

    source
    fn PaintFilter::compose(first : PaintFilter, second : PaintFilter) -> PaintFilter

    Compose two filters in application order: first, then second.

    PaintFilter::contrast

    source
    fn PaintFilter::contrast(factor : Double) -> PaintFilter

    Create a filter that scales RGB contrast around mid-gray and preserves alpha.

    PaintFilter::equal

    source
    fn PaintFilter::equal(PaintFilter, PaintFilter) -> Bool

    PaintFilter::get_filter_count

    source
    fn PaintFilter::get_filter_count(self : PaintFilter) -> Int

    Return the number of filter stages in this chain.

    PaintFilter::get_stage_color

    source
    fn PaintFilter::get_stage_color(self : PaintFilter, index : Int) -> Color?

    Return the stage color for color-bearing filter stages.

    PaintFilter::get_stage_color_matrix

    source
    fn PaintFilter::get_stage_color_matrix(self : PaintFilter, index : Int) -> Array[Double]?

    Return a copied 4x5 RGBA color matrix for matrix filter stages.

    PaintFilter::get_stage_factor

    source
    fn PaintFilter::get_stage_factor(self : PaintFilter, index : Int) -> Double?

    Return the numeric factor for factor-bearing filter stages.

    PaintFilter::get_stage_type

    source
    fn PaintFilter::get_stage_type(self : PaintFilter, index : Int) -> PaintFilterType?

    Return the filter stage family at an index.

    PaintFilter::grayscale

    source
    fn PaintFilter::grayscale() -> PaintFilter

    Create a filter that converts RGB channels to luminance and preserves alpha.

    PaintFilter::identity

    source
    fn PaintFilter::identity() -> PaintFilter

    Create a filter chain with no stages. Applying it returns the source color.

    PaintFilter::invert

    source
    fn PaintFilter::invert() -> PaintFilter

    Create a filter that inverts RGB channels and preserves alpha.

    PaintFilter::is_identity

    source
    fn PaintFilter::is_identity(self : PaintFilter) -> Bool

    Return whether this filter chain has no stages.

    PaintFilter::modulate

    source
    fn PaintFilter::modulate(color : Color) -> PaintFilter

    Create a filter that multiplies each source channel by a color.

    PaintFilter::not_equal

    source
    fn PaintFilter::not_equal(x : PaintFilter, y : PaintFilter) -> Bool

    PaintFilter::saturate

    source
    fn PaintFilter::saturate(factor : Double) -> PaintFilter

    Create a filter that scales RGB saturation around luminance and preserves alpha.

    PaintFilter::sepia

    source
    fn PaintFilter::sepia() -> PaintFilter

    Create a filter that maps RGB channels through a warm sepia tone matrix.

    PaintFilter::then

    source
    fn PaintFilter::then(self : PaintFilter, next : PaintFilter) -> PaintFilter

    Return a filter that applies this filter and then the next filter.

    PaintFilter::to_repr

    source

    PaintFilterType

    source
    pub(all) enum PaintFilterType {
      Modulate
      Grayscale
      Invert
      Brightness
      Contrast
      Saturate
      Sepia
      ColorMatrix
    } derive(Eq, 
    Debug    )

    Public filter stage family used for inspection and paint pipeline planning.

    PaintFilterType::equal

    source

    PaintFilterType::not_equal

    source
    fn PaintFilterType::not_equal(x : PaintFilterType, y : PaintFilterType) -> Bool

    PaintFilterType::to_repr

    source

    PaintGradientStop

    source
    type PaintGradientStop derive(Eq, 
    Debug    )

    One color stop in a gradient shader.

    PaintGradientStop::equal

    source

    PaintGradientStop::get_color

    source
    fn PaintGradientStop::get_color(self : PaintGradientStop) -> Color

    Return this stop's color.

    PaintGradientStop::get_offset

    source
    fn PaintGradientStop::get_offset(self : PaintGradientStop) -> Double

    Return this stop's normalized offset.

    PaintGradientStop::new

    source
    fn PaintGradientStop::new(offset~ : Double, color~ : Color) -> PaintGradientStop

    Create a gradient color stop. Offsets are clamped into 0.0..1.0.

    PaintGradientStop::not_equal

    source
    fn PaintGradientStop::not_equal(x : PaintGradientStop, y : PaintGradientStop) -> Bool

    PaintGradientStop::to_repr

    source

    PaintShader

    source
    type PaintShader derive(Eq, 
    Debug    )

    Device-space shader used as a Paint color source.

    PaintShader::equal

    source
    fn PaintShader::equal(PaintShader, PaintShader) -> Bool

    PaintShader::get_gradient_stop

    source
    fn PaintShader::get_gradient_stop(self : PaintShader, index : Int) -> PaintGradientStop?

    Return a copied gradient stop at an index.

    PaintShader::get_gradient_stop_count

    source
    fn PaintShader::get_gradient_stop_count(self : PaintShader) -> Int

    Return the number of color stops used by this gradient. Two-color gradient constructors report their implicit start/end stop pair.

    PaintShader::get_gradient_stops

    source
    fn PaintShader::get_gradient_stops(self : PaintShader) -> Array[PaintGradientStop]

    Return a copied gradient stop list. Two-color gradient constructors expose their implicit start/end pair as stops at 0.0 and 1.0.

    PaintShader::get_linear_gradient_points

    source
    fn PaintShader::get_linear_gradient_points(self : PaintShader) -> (Point, Point)?

    Return local linear-gradient endpoints, if this is a linear gradient.

    PaintShader::get_local_from_device_transform

    source
    fn PaintShader::get_local_from_device_transform(self : PaintShader) -> Transform?

    Return the local-from-device transform used before sampling, if any.

    PaintShader::get_radial_gradient_circle

    source
    fn PaintShader::get_radial_gradient_circle(self : PaintShader) -> (Point, Double)?

    Return local radial-gradient center and radius, if this is a radial gradient.

    PaintShader::get_spread

    source
    fn PaintShader::get_spread(self : PaintShader) -> PaintShaderSpread

    Return the gradient spread mode.

    PaintShader::get_sweep_gradient_geometry

    source
    fn PaintShader::get_sweep_gradient_geometry(self : PaintShader) -> (Point, Double, Double)?

    Return local sweep-gradient center and angles, if this is a sweep gradient.

    PaintShader::get_type

    source
    fn PaintShader::get_type(self : PaintShader) -> PaintShaderType

    Return the shader family.

    PaintShader::has_local_transform

    source
    fn PaintShader::has_local_transform(self : PaintShader) -> Bool

    Return whether this shader has a local-to-device transform attached.

    PaintShader::is_sampleable

    source
    fn PaintShader::is_sampleable(self : PaintShader) -> Bool

    Return whether this shader can produce non-transparent samples. Singular transforms mark a shader as unsampleable.

    PaintShader::linear_gradient

    source
    fn PaintShader::linear_gradient(x0~ : Double, y0~ : Double, x1~ : Double, y1~ : Double, start_color~ : Color, end_color~ : Color, spread? : PaintShaderSpread) -> PaintShader

    Create a device-space linear gradient shader.

    PaintShader::linear_gradient_stops

    source
    fn PaintShader::linear_gradient_stops(x0~ : Double, y0~ : Double, x1~ : Double, y1~ : Double, stops~ : Array[PaintGradientStop], spread? : PaintShaderSpread) -> PaintShader

    Create a device-space linear gradient shader with multiple color stops.

    PaintShader::not_equal

    source
    fn PaintShader::not_equal(x : PaintShader, y : PaintShader) -> Bool

    PaintShader::radial_gradient

    source
    fn PaintShader::radial_gradient(cx~ : Double, cy~ : Double, radius~ : Double, start_color~ : Color, end_color~ : Color, spread? : PaintShaderSpread) -> PaintShader

    Create a device-space radial gradient shader.

    PaintShader::radial_gradient_stops

    source
    fn PaintShader::radial_gradient_stops(cx~ : Double, cy~ : Double, radius~ : Double, stops~ : Array[PaintGradientStop], spread? : PaintShaderSpread) -> PaintShader

    Create a device-space radial gradient shader with multiple color stops.

    PaintShader::sample

    source
    fn PaintShader::sample(self : PaintShader, x : Double, y : Double) -> Color

    Sample this shader at a device-space point.

    PaintShader::sweep_gradient

    source
    fn PaintShader::sweep_gradient(cx~ : Double, cy~ : Double, start_angle~ : Double, sweep_angle~ : Double, start_color~ : Color, end_color~ : Color, spread? : PaintShaderSpread) -> PaintShader

    Create a device-space sweep gradient shader around a center point.

    PaintShader::sweep_gradient_stops

    source
    fn PaintShader::sweep_gradient_stops(cx~ : Double, cy~ : Double, start_angle~ : Double, sweep_angle~ : Double, stops~ : Array[PaintGradientStop], spread? : PaintShaderSpread) -> PaintShader

    Create a device-space sweep gradient shader with multiple color stops.

    PaintShader::to_repr

    source

    PaintShader::transformed

    source
    fn PaintShader::transformed(self : PaintShader, transform : Transform) -> PaintShader

    Return a shader sampled in local coordinates mapped to device space by the given transform. Singular transforms make the shader sample transparent.

    PaintShaderSpread

    source
    pub(all) enum PaintShaderSpread {
      Clamp
      Repeat
      Mirror
      Decal
    } derive(Eq, 
    Debug    )

    Spread mode applied to gradient coordinates outside the unit interval.

    PaintShaderSpread::equal

    source

    PaintShaderSpread::not_equal

    source
    fn PaintShaderSpread::not_equal(x : PaintShaderSpread, y : PaintShaderSpread) -> Bool

    PaintShaderSpread::to_repr

    source

    PaintShaderType

    source
    pub(all) enum PaintShaderType {
      LinearGradient
      RadialGradient
      SweepGradient
    } derive(Eq, 
    Debug    )

    Public shader family used for inspection and paint pipeline planning.

    PaintShaderType::equal

    source

    PaintShaderType::not_equal

    source
    fn PaintShaderType::not_equal(x : PaintShaderType, y : PaintShaderType) -> Bool

    PaintShaderType::to_repr

    source

    PaintStyle

    source
    pub(all) enum PaintStyle {
      Fill
      Stroke
    } derive(Eq, 
    Debug    )

    Paint style

    PaintStyle::equal

    source
    fn PaintStyle::equal(PaintStyle, PaintStyle) -> Bool

    PaintStyle::not_equal

    source
    fn PaintStyle::not_equal(x : PaintStyle, y : PaintStyle) -> Bool

    PaintStyle::to_repr

    source

    Path

    source
    pub struct Path {
      segments : Array[PathSegment]
      current_x : Double
      current_y : Double
      start_x : Double
      start_y : Double
    } derive(
    Debug    )

    2D path builder for constructing vector shapes

    Path::add_arc

    source
    fn Path::add_arc(self : Path, cx : Double, cy : Double, radius : Double, start_angle : Double, sweep_angle : Double) -> Path

    Add an open circular arc approximated with cubic bezier curves.

    Path::add_circle

    source
    fn Path::add_circle(self : Path, cx : Double, cy : Double, radius : Double) -> Path

    Add a circle approximation using cubic bezier curves

    Path::add_ellipse

    source
    fn Path::add_ellipse(self : Path, cx : Double, cy : Double, rx : Double, ry : Double) -> Path

    Add an ellipse approximation using cubic bezier curves

    Path::add_pie

    source
    fn Path::add_pie(self : Path, cx : Double, cy : Double, radius : Double, start_angle : Double, sweep_angle : Double) -> Path

    Add a closed pie slice from the center through a circular arc.

    Path::add_polygon

    source
    fn Path::add_polygon(self : Path, points : Array[Point]) -> Path

    Add a closed polygon through the given points

    Path::add_polyline

    source
    fn Path::add_polyline(self : Path, points : Array[Point]) -> Path

    Add an open polyline through the given points

    Path::add_rect

    source
    fn Path::add_rect(self : Path, x : Double, y : Double, w : Double, h : Double) -> Path

    Add a rectangle to the path

    Path::add_rounded_rect

    source
    fn Path::add_rounded_rect(self : Path, x : Double, y : Double, w : Double, h : Double, radius : Double) -> Path

    Add a rounded rectangle with a uniform corner radius to the path

    Path::add_rounded_rect_corners

    source
    fn Path::add_rounded_rect_corners(self : Path, x : Double, y : Double, w : Double, h : Double, top_left : Double, top_right : Double, bottom_right : Double, bottom_left : Double) -> Path

    Add a rounded rectangle with independent corner radii in clockwise order.

    Path::boolean

    source
    fn Path::boolean(self : Path, other : Path, op : PathBooleanOp) -> Path?

    Boolean two supported path shapes. Empty paths follow geometric identity rules. Rect-like paths and single convex line-polygon paths support all operations. Single axis-aligned line polygons are decomposed into rectangle cells so common GUI clip shapes such as L regions can also be combined. Other non-convex or curved operands are currently rejected with None.

    Path::close

    source
    fn Path::close(self : Path) -> Path

    Close the current subpath

    Path::contains_point

    source
    fn Path::contains_point(self : Path, x : Double, y : Double, fill_rule : FillRule) -> Bool

    Return whether a point is inside this path under the given fill rule.

    Path::control_bounds

    source
    fn Path::control_bounds(self : Path) -> Rect?

    Return conservative bounds over all explicit path control points.

    Path::cubic_to

    source
    fn Path::cubic_to(self : Path, cx1 : Double, cy1 : Double, cx2 : Double, cy2 : Double, x : Double, y : Double) -> Path

    Draw a cubic bezier curve

    Path::difference

    source
    fn Path::difference(self : Path, other : Path) -> Path?

    Return the geometric difference of this path minus another supported shape.

    Path::get_segments

    source
    fn Path::get_segments(self : Path) -> Array[PathSegment]

    Get the segments of the path

    Path::intersection

    source
    fn Path::intersection(self : Path, other : Path) -> Path?

    Return the geometric intersection of two supported path shapes.

    Path::is_empty

    source
    fn Path::is_empty(self : Path) -> Bool

    Check if the path is empty

    Path::is_line_polygon

    source
    fn Path::is_line_polygon(self : Path) -> Bool

    Return whether this path can be treated as one simplified closed line polygon.

    Path::line_polygon_area

    source
    fn Path::line_polygon_area(self : Path) -> Double?

    Return the absolute shoelace area for one simplified closed line polygon.

    Path::line_polygon_points

    source
    fn Path::line_polygon_points(self : Path) -> Array[Point]?

    Return isolated points when this path is one simplified closed line polygon.

    Path::line_polygon_signed_area

    source
    fn Path::line_polygon_signed_area(self : Path) -> Double?

    Return the signed shoelace area for one simplified closed line polygon.

    Path::line_to

    source
    fn Path::line_to(self : Path, x : Double, y : Double) -> Path

    Draw a line to a point

    Path::move_to

    source
    fn Path::move_to(self : Path, x : Double, y : Double) -> Path

    Move to a point without drawing

    Path::new

    source
    fn Path::new() -> Path

    Create a new empty path

    Path::quad_to

    source
    fn Path::quad_to(self : Path, cx : Double, cy : Double, x : Double, y : Double) -> Path

    Draw a quadratic bezier curve

    Path::rect_boolean

    source
    fn Path::rect_boolean(self : Path, other : Path, op : PathBooleanOp) -> Path?

    Boolean two axis-aligned rectangle paths by decomposing them into non-overlapping rectangle cells. Returns None when either operand is not a single rect-like path.

    Path::rect_bounds

    source
    fn Path::rect_bounds(self : Path) -> Rect?

    Return normalized bounds when this path is one closed axis-aligned rectangle.

    Path::segment_count

    source
    fn Path::segment_count(self : Path) -> Int

    Return the number of path segments without exposing the segment array.

    Path::simplified

    source
    fn Path::simplified(self : Path) -> Path

    Return a copy with exact no-op segments removed.

    This keeps path geometry intact while coalescing consecutive moves, removing zero-length line segments, removing fully degenerate curves, and dropping repeated close commands and empty subpaths, including trailing open moves. Explicit line-to-start segments immediately before close commands are folded into the close. Curves that trace the same straight span with monotonic control points are folded into line segments. Contiguous line segments that keep moving along the same straight span are coalesced.

    Path::to_repr

    source

    Path::transformed

    source
    fn Path::transformed(self : Path, transform : Transform) -> Path

    Return a copy of this path with all explicit coordinates transformed.

    Path::union

    source
    fn Path::union(self : Path, other : Path) -> Path?

    Return the geometric union of two supported path shapes.

    Path::xor

    source
    fn Path::xor(self : Path, other : Path) -> Path?

    Return the geometric symmetric difference of two supported path shapes.

    PathBooleanOp

    source
    pub(all) enum PathBooleanOp {
      Union
      Intersection
      Difference
      Xor
    } derive(Eq, 
    Debug    )

    Boolean operation for supported path operands.

    PathBooleanOp::equal

    source

    PathBooleanOp::not_equal

    source
    fn PathBooleanOp::not_equal(x : PathBooleanOp, y : PathBooleanOp) -> Bool

    PathBooleanOp::to_repr

    source

    PathSegment

    source
    pub enum PathSegment {
      MoveTo(Double, Double)
      LineTo(Double, Double)
      QuadTo(Double, Double, Double, Double)
      CubicTo(Double, Double, Double, Double, Double, Double)
      Close
    } derive(Eq, 
    Debug    )

    Path segment types

    PathSegment::equal

    source
    fn PathSegment::equal(PathSegment, PathSegment) -> Bool

    PathSegment::not_equal

    source
    fn PathSegment::not_equal(x : PathSegment, y : PathSegment) -> Bool

    PathSegment::to_repr

    source

    PixelRect

    source
    pub struct PixelRect {
      x : Int
      y : Int
      width : Int
      height : Int
    } derive(Eq, 
    Debug    )

    Pixel-aligned rectangle used for dirty-region tracking.

    PixelRect::area

    source
    fn PixelRect::area(self : PixelRect) -> Int

    PixelRect::bottom

    source
    fn PixelRect::bottom(self : PixelRect) -> Int

    PixelRect::clip_to

    source
    fn PixelRect::clip_to(self : PixelRect, bounds : PixelRect) -> PixelRect?

    PixelRect::contains

    source
    fn PixelRect::contains(self : PixelRect, x : Int, y : Int) -> Bool

    PixelRect::equal

    source
    fn PixelRect::equal(PixelRect, PixelRect) -> Bool

    PixelRect::intersection

    source
    fn PixelRect::intersection(self : PixelRect, other : PixelRect) -> PixelRect?

    PixelRect::intersects

    source
    fn PixelRect::intersects(self : PixelRect, other : PixelRect) -> Bool

    PixelRect::is_empty

    source
    fn PixelRect::is_empty(self : PixelRect) -> Bool

    PixelRect::new

    source
    fn PixelRect::new(x~ : Int, y~ : Int, width~ : Int, height~ : Int) -> PixelRect

    PixelRect::not_equal

    source
    fn PixelRect::not_equal(x : PixelRect, y : PixelRect) -> Bool

    PixelRect::right

    source
    fn PixelRect::right(self : PixelRect) -> Int

    PixelRect::to_repr

    source

    PixelRect::union

    source
    fn PixelRect::union(self : PixelRect, other : PixelRect) -> PixelRect

    Pixmap

    source
    pub struct Pixmap {
      width : Int
      height : Int
      pixels : FixedArray[Byte]
    } derive(
    Debug    )

    Pixel buffer for 2D rendering (RGBA format)

    Pixmap::blend_mask

    source
    fn Pixmap::blend_mask(self : Pixmap, x : Int, y : Int, width : Int, height : Int, mask : FixedArray[Byte], color : Color) -> Unit

    Composite a grayscale coverage mask over the existing pixels

    Pixmap::blend_mask_rect

    source
    fn Pixmap::blend_mask_rect(self : Pixmap, x : Int, y : Int, mask_width : Int, mask_height : Int, mask : FixedArray[Byte], src_rect : PixelRect, color : Color) -> Unit

    Composite a source rectangle from a grayscale coverage mask over this pixmap.

    Pixmap::blend_nine_patch_pixmap

    source
    fn Pixmap::blend_nine_patch_pixmap(self : Pixmap, x : Int, y : Int, width : Int, height : Int, src : Pixmap, insets : NinePatchInsets, opacity : Double, sampling : ImageSampling) -> Unit

    Composite a source pixmap using nine-patch scaling.

    Pixmap::blend_pixel

    source
    fn Pixmap::blend_pixel(self : Pixmap, x : Int, y : Int, color : Color) -> Unit

    Composite a pixel over the existing pixel at the given coordinates

    Pixmap::blend_pixmap

    source
    fn Pixmap::blend_pixmap(self : Pixmap, x : Int, y : Int, src : Pixmap, opacity : Double) -> Unit

    Composite another pixmap over this pixmap at the given destination position.

    Pixmap::blend_pixmap_rect

    source
    fn Pixmap::blend_pixmap_rect(self : Pixmap, x : Int, y : Int, src : Pixmap, src_rect : PixelRect, opacity : Double) -> Unit

    Composite a source pixmap rectangle over this pixmap at the destination position corresponding to the requested source rectangle's top-left corner.

    Pixmap::blend_quality_nine_patch_pixmap

    source
    fn Pixmap::blend_quality_nine_patch_pixmap(self : Pixmap, x : Int, y : Int, width : Int, height : Int, src : Pixmap, insets : NinePatchInsets, opacity : Double, quality : ImageQuality) -> Unit

    Composite a source pixmap using nine-patch scaling and a quality strategy.

    Pixmap::blend_quality_pixmap

    source
    fn Pixmap::blend_quality_pixmap(self : Pixmap, x : Int, y : Int, width : Int, height : Int, src : Pixmap, opacity : Double, quality : ImageQuality) -> Unit

    Composite another pixmap scaled with a quality strategy.

    Pixmap::blend_quality_pixmap_rect

    source
    fn Pixmap::blend_quality_pixmap_rect(self : Pixmap, x : Int, y : Int, width : Int, height : Int, src : Pixmap, src_rect : PixelRect, opacity : Double, quality : ImageQuality) -> Unit

    Composite a source pixmap rectangle scaled with a quality strategy.

    Pixmap::blend_rect

    source
    fn Pixmap::blend_rect(self : Pixmap, x : Int, y : Int, w : Int, h : Int, color : Color) -> Unit

    Composite a rectangle over the existing pixels

    Pixmap::blend_sampled_pixmap

    source
    fn Pixmap::blend_sampled_pixmap(self : Pixmap, x : Int, y : Int, width : Int, height : Int, src : Pixmap, opacity : Double, sampling : ImageSampling) -> Unit

    Composite another pixmap scaled with an explicit sampling mode.

    Pixmap::blend_sampled_pixmap_rect

    source
    fn Pixmap::blend_sampled_pixmap_rect(self : Pixmap, x : Int, y : Int, width : Int, height : Int, src : Pixmap, src_rect : PixelRect, opacity : Double, sampling : ImageSampling) -> Unit

    Composite a source pixmap rectangle scaled with an explicit sampling mode.

    Pixmap::blend_scaled_pixmap

    source
    fn Pixmap::blend_scaled_pixmap(self : Pixmap, x : Int, y : Int, width : Int, height : Int, src : Pixmap, opacity : Double) -> Unit

    Composite another pixmap scaled to the given destination size.

    Pixmap::blend_scaled_pixmap_bicubic

    source
    fn Pixmap::blend_scaled_pixmap_bicubic(self : Pixmap, x : Int, y : Int, width : Int, height : Int, src : Pixmap, opacity : Double) -> Unit

    Composite another pixmap scaled with bicubic sampling.

    Pixmap::blend_scaled_pixmap_bilinear

    source
    fn Pixmap::blend_scaled_pixmap_bilinear(self : Pixmap, x : Int, y : Int, width : Int, height : Int, src : Pixmap, opacity : Double) -> Unit

    Composite another pixmap scaled with bilinear sampling.

    Pixmap::blend_scaled_pixmap_rect

    source
    fn Pixmap::blend_scaled_pixmap_rect(self : Pixmap, x : Int, y : Int, width : Int, height : Int, src : Pixmap, src_rect : PixelRect, opacity : Double) -> Unit

    Composite a source pixmap rectangle scaled to the given destination size.

    Pixmap::blend_scaled_pixmap_rect_bicubic

    source
    fn Pixmap::blend_scaled_pixmap_rect_bicubic(self : Pixmap, x : Int, y : Int, width : Int, height : Int, src : Pixmap, src_rect : PixelRect, opacity : Double) -> Unit

    Composite a source pixmap rectangle scaled with bicubic sampling.

    Pixmap::blend_scaled_pixmap_rect_bilinear

    source
    fn Pixmap::blend_scaled_pixmap_rect_bilinear(self : Pixmap, x : Int, y : Int, width : Int, height : Int, src : Pixmap, src_rect : PixelRect, opacity : Double) -> Unit

    Composite a source pixmap rectangle scaled with bilinear sampling.

    Pixmap::blend_tiled_pixmap_rect

    source
    fn Pixmap::blend_tiled_pixmap_rect(self : Pixmap, x : Int, y : Int, width : Int, height : Int, src : Pixmap, src_rect : PixelRect, opacity : Double) -> Unit

    Composite a source pixmap rectangle repeatedly into the destination area.

    Pixmap::checksum

    source
    fn Pixmap::checksum(self : Pixmap) -> Int

    Return a deterministic lightweight checksum of the raw RGBA pixel bytes. This is intended for compact regression assertions and smoke telemetry, not for cryptographic or collision-resistant validation.

    Pixmap::checksum_rect

    source
    fn Pixmap::checksum_rect(self : Pixmap, rect : PixelRect) -> Result[Int, PresentError]

    Return a deterministic lightweight checksum of a pixmap rectangle.

    Pixmap::clear

    source
    fn Pixmap::clear(self : Pixmap, color : Color) -> Unit

    Clear the pixmap with a color

    Pixmap::copy

    source
    fn Pixmap::copy(self : Pixmap) -> Pixmap

    Copy this pixmap and its raw pixel storage.

    Pixmap::copy_rect

    source
    fn Pixmap::copy_rect(self : Pixmap, rect : PixelRect) -> Result[Pixmap, PresentError]

    Snapshot a rectangle of this pixmap into an isolated pixmap.

    Pixmap::fill_rect

    source
    fn Pixmap::fill_rect(self : Pixmap, x : Int, y : Int, w : Int, h : Int, color : Color) -> Unit

    Fill a rectangle with a color

    Pixmap::from_bmp_bytes

    source
    fn Pixmap::from_bmp_bytes(data : Bytes) -> Result[Pixmap, PixmapDecodeError]

    Decode a 24-bit or 32-bit BMP image into an RGBA pixmap.

    This intentionally supports uncompressed BMP images with BGR/BGRA pixels. Both bottom-up and top-down BMP row order are accepted.

    Pixmap::from_png_bytes

    source
    fn Pixmap::from_png_bytes(data : Bytes) -> Result[Pixmap, PixmapDecodeError]

    Decode an 8-bit RGBA PNG image into a pixmap.

    This decoder supports non-interlaced PNGs with RGBA color, standard scanline filters, and zlib-wrapped DEFLATE image data. It is intentionally paired with to_png_bytes for portable fixture roundtrips.

    Pixmap::from_rgba_bytes

    source
    fn Pixmap::from_rgba_bytes(width : Int, height : Int, data : Bytes) -> Result[Pixmap, PixmapDecodeError]

    Decode tightly packed RGBA bytes into a pixmap.

    The input must contain exactly width * height * 4 bytes in row-major RGBA order. Decoded pixels are copied so later mutations to the returned pixmap cannot alias caller-owned byte storage.

    Pixmap::get_height

    source
    fn Pixmap::get_height(self : Pixmap) -> Int

    Get the height of the pixmap

    Pixmap::get_pixel

    source
    fn Pixmap::get_pixel(self : Pixmap, x : Int, y : Int) -> Color

    Get the color at the given coordinates

    Pixmap::get_pixels

    source
    fn Pixmap::get_pixels(self : Pixmap) -> FixedArray[Byte]

    Get the raw pixel data

    Pixmap::get_width

    source
    fn Pixmap::get_width(self : Pixmap) -> Int

    Get the width of the pixmap

    Pixmap::new

    source
    fn Pixmap::new(width : Int, height : Int) -> Pixmap

    Create a new pixmap filled with transparent pixels

    Pixmap::present_batch

    source
    fn Pixmap::present_batch(self : Pixmap, plan : DirtyPresentPlan) -> Result[PresentBatch, PresentError]

    Pixmap::present_rect_payload

    source
    fn Pixmap::present_rect_payload(self : Pixmap, rect : PixelRect) -> Result[PresentRectPayload, PresentError]

    Pixmap::present_rect_to

    source
    fn[S : Surface] Pixmap::present_rect_to(self : Pixmap, surface : S, rect : PixelRect) -> Result[Unit, PresentError]

    Pixmap::present_to

    source
    fn[S : Surface] Pixmap::present_to(self : Pixmap, surface : S) -> Result[Unit, PresentError]

    Pixmap::set_pixel

    source
    fn Pixmap::set_pixel(self : Pixmap, x : Int, y : Int, color : Color) -> Unit

    Set a pixel at the given coordinates

    Pixmap::to_bmp_bytes

    source
    fn Pixmap::to_bmp_bytes(self : Pixmap) -> Bytes

    Encode this pixmap as a deterministic 32-bit BMP image.

    Pixels are written in standard bottom-up BMP row order with BGRA channels, preserving the pixmap alpha channel for tools that understand 32-bit BMP.

    Pixmap::to_bmp_rect_bytes

    source
    fn Pixmap::to_bmp_rect_bytes(self : Pixmap, rect : PixelRect) -> Result[Bytes, PresentError]

    Encode a rectangle of this pixmap as deterministic 32-bit BMP(BGRA) bytes.

    Pixmap::to_png_bytes

    source
    fn Pixmap::to_png_bytes(self : Pixmap) -> Result[Bytes, PixmapEncodeError]

    Encode this pixmap as a deterministic 8-bit RGBA PNG image.

    The encoder writes filter-0 scanlines into uncompressed DEFLATE blocks, so the output is dependency-free and stable for headless render fixtures.

    Pixmap::to_png_rect_bytes

    source
    fn Pixmap::to_png_rect_bytes(self : Pixmap, rect : PixelRect) -> Result[Bytes, PresentError]

    Encode a rectangle of this pixmap as deterministic 8-bit RGBA PNG bytes.

    Pixmap::to_ppm_bytes

    source
    fn Pixmap::to_ppm_bytes(self : Pixmap) -> Bytes

    Encode this pixmap as a binary PPM (P6) image, dropping the alpha channel. The result is a deterministic, dependency-free fixture format for headless render tests and simple CPU-rendered pixel dumps.

    Pixmap::to_ppm_rect_bytes

    source
    fn Pixmap::to_ppm_rect_bytes(self : Pixmap, rect : PixelRect) -> Result[Bytes, PresentError]

    Encode a rectangle of this pixmap as deterministic binary PPM(P6) bytes.

    Pixmap::to_repr

    source

    Pixmap::to_rgba_bytes

    source
    fn Pixmap::to_rgba_bytes(self : Pixmap) -> Bytes

    Return an isolated copy of the raw RGBA pixel bytes in row-major order.

    Pixmap::to_rgba_rect_bytes

    source
    fn Pixmap::to_rgba_rect_bytes(self : Pixmap, rect : PixelRect) -> Result[Bytes, PresentError]

    Return packed RGBA bytes for a pixmap rectangle in row-major order.

    PixmapCache

    source
    pub struct PixmapCache {
      pixmaps : Map[String, Pixmap]
      access_order : Array[String]
      capacity : Int
      is_bounded : Bool
    } derive(
    Debug    )

    Small keyed cache for reusable pixmap resources.

    PixmapCache::capacity

    source
    fn PixmapCache::capacity(self : PixmapCache) -> Int

    Return the maximum number of cached pixmaps, or 0 for an unbounded cache.

    PixmapCache::clear

    source
    fn PixmapCache::clear(self : PixmapCache) -> Unit

    Drop all cached pixmaps.

    PixmapCache::contains

    source
    fn PixmapCache::contains(self : PixmapCache, key : String) -> Bool

    Return whether the cache has a pixmap for this key without refreshing LRU.

    PixmapCache::get

    source
    fn PixmapCache::get(self : PixmapCache, key : String) -> Pixmap?

    Look up a pixmap by caller-provided key.

    PixmapCache::get_or_decode_bmp

    source
    fn PixmapCache::get_or_decode_bmp(self : PixmapCache, key : String, data : Bytes) -> Result[Pixmap, PixmapDecodeError]

    Return a cached pixmap or decode BMP bytes and cache the decoded pixmap.

    PixmapCache::get_or_decode_bmp_result

    source
    fn PixmapCache::get_or_decode_bmp_result(self : PixmapCache, key : String, data : Bytes) -> Result[PixmapCacheDecodeResult, PixmapDecodeError]

    Return a cached pixmap or decode BMP bytes, reporting cache hits.

    PixmapCache::get_or_decode_png

    source
    fn PixmapCache::get_or_decode_png(self : PixmapCache, key : String, data : Bytes) -> Result[Pixmap, PixmapDecodeError]

    Return a cached pixmap or decode PNG bytes and cache the decoded pixmap.

    PixmapCache::get_or_decode_png_result

    source
    fn PixmapCache::get_or_decode_png_result(self : PixmapCache, key : String, data : Bytes) -> Result[PixmapCacheDecodeResult, PixmapDecodeError]

    Return a cached pixmap or decode PNG bytes, reporting cache hits.

    PixmapCache::get_or_decode_rgba

    source
    fn PixmapCache::get_or_decode_rgba(self : PixmapCache, key : String, width : Int, height : Int, data : Bytes) -> Result[Pixmap, PixmapDecodeError]

    Return a cached pixmap or decode raw RGBA bytes and cache the pixmap.

    PixmapCache::get_or_decode_rgba_result

    source
    fn PixmapCache::get_or_decode_rgba_result(self : PixmapCache, key : String, width : Int, height : Int, data : Bytes) -> Result[PixmapCacheDecodeResult, PixmapDecodeError]

    Return a cached pixmap or decode raw RGBA bytes, reporting cache hits.

    PixmapCache::get_or_insert

    source
    fn PixmapCache::get_or_insert(self : PixmapCache, key : String, pixmap : Pixmap) -> Pixmap

    Return a cached pixmap or insert this fallback pixmap on a miss.

    PixmapCache::get_or_insert_result

    source
    fn PixmapCache::get_or_insert_result(self : PixmapCache, key : String, pixmap : Pixmap) -> PixmapCacheInsertResult

    Return a cached pixmap or insert this fallback pixmap, reporting cache hits.

    PixmapCache::insert

    source
    fn PixmapCache::insert(self : PixmapCache, key : String, pixmap : Pixmap) -> Pixmap

    Insert or replace a pixmap under a caller-provided key.

    PixmapCache::is_capacity_bounded

    source
    fn PixmapCache::is_capacity_bounded(self : PixmapCache) -> Bool

    Return whether the cache has a configured entry limit.

    PixmapCache::is_empty

    source
    fn PixmapCache::is_empty(self : PixmapCache) -> Bool

    Return whether the cache currently has no pixmaps.

    PixmapCache::len

    source
    fn PixmapCache::len(self : PixmapCache) -> Int

    Return the number of cached pixmaps.

    PixmapCache::new

    source

    Create an empty pixmap cache.

    PixmapCache::remove

    source
    fn PixmapCache::remove(self : PixmapCache, key : String) -> Unit

    Remove a cached pixmap by key.

    PixmapCache::to_repr

    source

    PixmapCache::with_capacity

    source
    fn PixmapCache::with_capacity(capacity : Int) -> PixmapCache

    Create an empty pixmap cache with least-recently-used eviction.

    PixmapCacheDecodeResult

    source
    pub struct PixmapCacheDecodeResult {
      pixmap : Pixmap
      did_decode : Bool
    } derive(
    Debug    )

    Result of reading a pixmap from cache or decoding bytes on miss.

    PixmapCacheDecodeResult::did_decode

    source
    fn PixmapCacheDecodeResult::did_decode(self : PixmapCacheDecodeResult) -> Bool

    Return whether this lookup decoded bytes instead of hitting cache.

    PixmapCacheDecodeResult::did_hit_cache

    source
    fn PixmapCacheDecodeResult::did_hit_cache(self : PixmapCacheDecodeResult) -> Bool

    Return whether this lookup reused a cached pixmap.

    PixmapCacheDecodeResult::get_pixmap

    source

    Get the resulting pixmap.

    PixmapCacheDecodeResult::to_repr

    source

    PixmapCacheInsertResult

    source
    pub struct PixmapCacheInsertResult {
      pixmap : Pixmap
      did_insert : Bool
    } derive(
    Debug    )

    Result of reading a pixmap from cache or inserting it on miss.

    PixmapCacheInsertResult::did_hit_cache

    source
    fn PixmapCacheInsertResult::did_hit_cache(self : PixmapCacheInsertResult) -> Bool

    Return whether this lookup reused a cached pixmap.

    PixmapCacheInsertResult::did_insert

    source
    fn PixmapCacheInsertResult::did_insert(self : PixmapCacheInsertResult) -> Bool

    Return whether this lookup inserted a new pixmap instead of hitting cache.

    PixmapCacheInsertResult::get_pixmap

    source

    Get the resulting pixmap.

    PixmapCacheInsertResult::to_repr

    source

    PixmapDecodeError

    source
    pub(all) enum PixmapDecodeError {
      UnexpectedEndOfData(Int, Int, Int)
      InvalidRgbaDimensions(Int, Int)
      RgbaByteLengthMismatch(Int, Int)
      InvalidBmpSignature(Byte, Byte)
      UnsupportedBmpHeaderSize(Int)
      UnsupportedBmpColorPlanes(Int)
      UnsupportedBmpBitsPerPixel(Int)
      UnsupportedBmpCompression(Int)
      InvalidBmpDimensions(Int, Int)
      BmpPixelDataOutOfBounds(Int, Int, Int)
      InvalidPngSignature
      MissingPngImageHeader
      MissingPngImageData
      MissingPngImageEnd
      UnsupportedPngHeaderSize(Int)
      UnsupportedPngBitDepth(Int)
      UnsupportedPngColorType(Int)
      UnsupportedPngCompression(Int)
      UnsupportedPngFilter(Int)
      UnsupportedPngInterlace(Int)
      UnsupportedPngChunk(Int, Int, Int, Int)
      UnsupportedPngDeflateCompression(Int)
      UnsupportedPngDeflatePresetDictionary
      UnsupportedPngDeflateBlockType(Int)
      InvalidPngDeflateCode
      UnsupportedPngFilterType(Int)
      InvalidPngDimensions(Int, Int)
      InvalidPngZlibHeader(Int, Int)
      PngCrcMismatch(UInt, UInt)
      PngAdlerMismatch(UInt, UInt)
      PngStoredBlockLengthMismatch(Int, Int)
      PngInflateLengthMismatch(Int, Int)
      PngScanlineLengthMismatch(Int, Int)
    } derive(Eq, 
    Debug    )

    Error returned when decoding pixmap bytes.

    PixmapDecodeError::equal

    source

    PixmapDecodeError::not_equal

    source
    fn PixmapDecodeError::not_equal(x : PixmapDecodeError, y : PixmapDecodeError) -> Bool

    PixmapDecodeError::to_repr

    source

    PixmapEncodeError

    source
    pub(all) enum PixmapEncodeError {
      InvalidPngDimensions(Int, Int)
    } derive(Eq, 
    Debug    )

    Error returned when encoding pixmap bytes.

    PixmapEncodeError::equal

    source

    PixmapEncodeError::not_equal

    source
    fn PixmapEncodeError::not_equal(x : PixmapEncodeError, y : PixmapEncodeError) -> Bool

    PixmapEncodeError::to_repr

    source

    PngDeflateBitReader

    source
    type PngDeflateBitReader derive(
    Debug    )

    PngDeflateHuffman

    source
    type PngDeflateHuffman derive(
    Debug    )

    PngDeflateHuffmanEntry

    source
    type PngDeflateHuffmanEntry derive(
    Debug    )

    PngDeflateTables

    source
    type PngDeflateTables derive(
    Debug    )

    PngHeader

    source
    type PngHeader derive(
    Debug    )

    PngInfo

    source

    PngInfo::to_repr

    source

    Point

    source
    pub struct Point {
      x : Double
      y : Double
    } derive(Eq, 
    Debug    )

    2D point with floating point coordinates

    Point::equal

    source
    fn Point::equal(Point, Point) -> Bool

    Point::new

    source
    fn Point::new(x~ : Double, y~ : Double) -> Point

    Create a new point

    Point::not_equal

    source
    fn Point::not_equal(x : Point, y : Point) -> Bool

    Point::to_repr

    source

    PresentBatch

    source
    pub struct PresentBatch {
      payloads : Array[PresentRectPayload]
      present_pixel_count : Int
      present_byte_count : Int
    } derive(
    Debug    )

    A materialized batch of packed rectangle present payloads.

    PresentBatch::get_full_present_byte_savings

    source
    fn PresentBatch::get_full_present_byte_savings(self : PresentBatch, width : Int, height : Int) -> Int

    Return how many packed RGBA bytes this batch avoids compared with presenting the full target surface.

    PresentBatch::get_full_present_pixel_savings

    source
    fn PresentBatch::get_full_present_pixel_savings(self : PresentBatch, width : Int, height : Int) -> Int

    Return how many pixels this batch avoids compared with presenting the full target surface. Empty batches report no savings because they represent skip, not a partial present.

    PresentBatch::get_payloads

    source
    fn PresentBatch::get_payloads(self : PresentBatch) -> Array[PresentRectPayload]

    PresentBatch::get_present_bounds

    source
    fn PresentBatch::get_present_bounds(self : PresentBatch) -> PixelRect?

    PresentBatch::get_present_byte_count

    source
    fn PresentBatch::get_present_byte_count(self : PresentBatch) -> Int

    PresentBatch::get_present_pixel_count

    source
    fn PresentBatch::get_present_pixel_count(self : PresentBatch) -> Int

    PresentBatch::get_present_strategy

    source
    fn PresentBatch::get_present_strategy(self : PresentBatch, width : Int, height : Int) -> DirtyPresentStrategy

    PresentBatch::get_rect_count

    source
    fn PresentBatch::get_rect_count(self : PresentBatch) -> Int

    PresentBatch::get_source_byte_count

    source
    fn PresentBatch::get_source_byte_count(self : PresentBatch) -> Int

    PresentBatch::get_source_padding_byte_count

    source
    fn PresentBatch::get_source_padding_byte_count(self : PresentBatch) -> Int

    PresentBatch::is_empty

    source
    fn PresentBatch::is_empty(self : PresentBatch) -> Bool

    PresentBatch::saves_full_present_pixels

    source
    fn PresentBatch::saves_full_present_pixels(self : PresentBatch, width : Int, height : Int) -> Bool

    PresentBatch::submit_plan_for

    source
    fn[S : Surface] PresentBatch::submit_plan_for(self : PresentBatch, surface : S) -> Result[PresentBatchSubmitPlan, PresentError]

    Build a validated dry-run submit plan for this packed batch without presenting any payloads to the surface.

    PresentBatch::submit_to

    source
    fn[S : Surface] PresentBatch::submit_to(self : PresentBatch, surface : S) -> Result[Int, PresentError]

    PresentBatch::submit_to_result

    source
    fn[S : Surface] PresentBatch::submit_to_result(self : PresentBatch, surface : S) -> Result[PresentBatchSubmitResult, PresentError]

    PresentBatch::to_repr

    source

    PresentBatch::validate_for

    source
    fn[S : Surface] PresentBatch::validate_for(self : PresentBatch, surface : S) -> Result[Unit, PresentError]

    Validate every payload in this batch against a target surface before any present call mutates backend state.

    PresentBatchSubmitPlan

    source
    pub struct PresentBatchSubmitPlan {
      batch : PresentBatch
      surface_width : Int
      surface_height : Int
    } derive(
    Debug    )

    Validated dry-run plan for submitting a materialized present batch to a concrete surface.

    PresentBatchSubmitPlan::get_batch

    source

    PresentBatchSubmitPlan::get_full_present_byte_savings

    source
    fn PresentBatchSubmitPlan::get_full_present_byte_savings(self : PresentBatchSubmitPlan) -> Int

    PresentBatchSubmitPlan::get_full_present_pixel_savings

    source
    fn PresentBatchSubmitPlan::get_full_present_pixel_savings(self : PresentBatchSubmitPlan) -> Int

    PresentBatchSubmitPlan::get_present_bounds

    source
    fn PresentBatchSubmitPlan::get_present_bounds(self : PresentBatchSubmitPlan) -> PixelRect?

    PresentBatchSubmitPlan::get_present_byte_count

    source
    fn PresentBatchSubmitPlan::get_present_byte_count(self : PresentBatchSubmitPlan) -> Int

    PresentBatchSubmitPlan::get_present_pixel_count

    source
    fn PresentBatchSubmitPlan::get_present_pixel_count(self : PresentBatchSubmitPlan) -> Int

    PresentBatchSubmitPlan::get_present_strategy

    source

    PresentBatchSubmitPlan::get_rect_count

    source
    fn PresentBatchSubmitPlan::get_rect_count(self : PresentBatchSubmitPlan) -> Int

    PresentBatchSubmitPlan::get_source_byte_count

    source
    fn PresentBatchSubmitPlan::get_source_byte_count(self : PresentBatchSubmitPlan) -> Int

    PresentBatchSubmitPlan::get_source_padding_byte_count

    source
    fn PresentBatchSubmitPlan::get_source_padding_byte_count(self : PresentBatchSubmitPlan) -> Int

    PresentBatchSubmitPlan::get_surface_height

    source
    fn PresentBatchSubmitPlan::get_surface_height(self : PresentBatchSubmitPlan) -> Int

    PresentBatchSubmitPlan::get_surface_width

    source
    fn PresentBatchSubmitPlan::get_surface_width(self : PresentBatchSubmitPlan) -> Int

    PresentBatchSubmitPlan::needs_present

    source
    fn PresentBatchSubmitPlan::needs_present(self : PresentBatchSubmitPlan) -> Bool

    PresentBatchSubmitPlan::saves_full_present_pixels

    source
    fn PresentBatchSubmitPlan::saves_full_present_pixels(self : PresentBatchSubmitPlan) -> Bool

    PresentBatchSubmitPlan::submit_to

    source
    fn[S : Surface] PresentBatchSubmitPlan::submit_to(self : PresentBatchSubmitPlan, surface : S) -> Result[Int, PresentError]

    Submit this prevalidated plan to a surface with the same dimensions.

    PresentBatchSubmitPlan::submit_to_result

    source
    fn[S : Surface] PresentBatchSubmitPlan::submit_to_result(self : PresentBatchSubmitPlan, surface : S) -> Result[PresentBatchSubmitResult, PresentError]

    Submit this prevalidated plan and return lifecycle telemetry.

    The target surface must still match the dimensions captured by the dry-run plan, so stale resize-era plans fail before any backend present call.

    PresentBatchSubmitPlan::to_repr

    source

    PresentBatchSubmitResult

    source
    pub struct PresentBatchSubmitResult {
      submit_plan : PresentBatchSubmitPlan
      presented_rect_count : Int
    } derive(
    Debug    )

    Result of submitting a materialized present batch to a concrete surface.

    PresentBatchSubmitResult::did_present

    source
    fn PresentBatchSubmitResult::did_present(self : PresentBatchSubmitResult) -> Bool

    PresentBatchSubmitResult::get_batch

    source

    PresentBatchSubmitResult::get_full_present_byte_savings

    source
    fn PresentBatchSubmitResult::get_full_present_byte_savings(self : PresentBatchSubmitResult) -> Int

    PresentBatchSubmitResult::get_full_present_pixel_savings

    source
    fn PresentBatchSubmitResult::get_full_present_pixel_savings(self : PresentBatchSubmitResult) -> Int

    PresentBatchSubmitResult::get_present_bounds

    source

    PresentBatchSubmitResult::get_present_byte_count

    source
    fn PresentBatchSubmitResult::get_present_byte_count(self : PresentBatchSubmitResult) -> Int

    PresentBatchSubmitResult::get_present_pixel_count

    source
    fn PresentBatchSubmitResult::get_present_pixel_count(self : PresentBatchSubmitResult) -> Int

    PresentBatchSubmitResult::get_present_strategy

    source

    PresentBatchSubmitResult::get_presented_rect_count

    source
    fn PresentBatchSubmitResult::get_presented_rect_count(self : PresentBatchSubmitResult) -> Int

    PresentBatchSubmitResult::get_rect_count

    source
    fn PresentBatchSubmitResult::get_rect_count(self : PresentBatchSubmitResult) -> Int

    PresentBatchSubmitResult::get_source_byte_count

    source
    fn PresentBatchSubmitResult::get_source_byte_count(self : PresentBatchSubmitResult) -> Int

    PresentBatchSubmitResult::get_source_padding_byte_count

    source
    fn PresentBatchSubmitResult::get_source_padding_byte_count(self : PresentBatchSubmitResult) -> Int

    PresentBatchSubmitResult::get_submit_plan

    source

    PresentBatchSubmitResult::get_surface_height

    source
    fn PresentBatchSubmitResult::get_surface_height(self : PresentBatchSubmitResult) -> Int

    PresentBatchSubmitResult::get_surface_width

    source
    fn PresentBatchSubmitResult::get_surface_width(self : PresentBatchSubmitResult) -> Int

    PresentBatchSubmitResult::needs_present

    source
    fn PresentBatchSubmitResult::needs_present(self : PresentBatchSubmitResult) -> Bool

    PresentBatchSubmitResult::saves_full_present_pixels

    source
    fn PresentBatchSubmitResult::saves_full_present_pixels(self : PresentBatchSubmitResult) -> Bool

    PresentBatchSubmitResult::to_repr

    source

    PresentError

    source
    pub(all) enum PresentError {
      InvalidDimensions(Int, Int)
      SizeMismatch(Int, Int, Int, Int)
      RectOutOfBounds(Int, Int, Int, Int, Int, Int)
      InvalidRowBytes(Int, Int)
      PixelBufferTooSmall(Int, Int)
    } derive(Eq, 
    Debug    )

    Error returned when presenting RGBA pixels to a surface fails.

    PresentError::equal

    source

    PresentError::not_equal

    source
    fn PresentError::not_equal(x : PresentError, y : PresentError) -> Bool

    PresentError::to_repr

    source

    PresentRectInfo

    source
    pub(all) struct PresentRectInfo {
      required_row_bytes : Int
      required_len : Int
    } derive(Eq, 
    Debug    )

    Validated geometry for a rectangle present call. Backends can use this to share row-stride and buffer-size checks with the reference MemorySurface.

    PresentRectInfo::equal

    source

    PresentRectInfo::not_equal

    source
    fn PresentRectInfo::not_equal(x : PresentRectInfo, y : PresentRectInfo) -> Bool

    PresentRectInfo::required_len

    source
    fn PresentRectInfo::required_len(self : PresentRectInfo) -> Int

    PresentRectInfo::required_row_bytes

    source
    fn PresentRectInfo::required_row_bytes(self : PresentRectInfo) -> Int

    PresentRectInfo::to_repr

    source

    PresentRectPayload

    source
    pub struct PresentRectPayload {
      rect : PixelRect
      row_bytes : Int
      pixels : FixedArray[Byte]
    } derive(
    Debug    )

    Packed source pixels for one rectangle present operation.

    PresentRectPayload::get_pixels

    source
    fn PresentRectPayload::get_pixels(self : PresentRectPayload) -> FixedArray[Byte]

    PresentRectPayload::get_present_byte_count

    source
    fn PresentRectPayload::get_present_byte_count(self : PresentRectPayload) -> Int

    PresentRectPayload::get_present_pixel_count

    source
    fn PresentRectPayload::get_present_pixel_count(self : PresentRectPayload) -> Int

    PresentRectPayload::get_rect

    source

    PresentRectPayload::get_row_bytes

    source
    fn PresentRectPayload::get_row_bytes(self : PresentRectPayload) -> Int

    PresentRectPayload::get_source_byte_count

    source
    fn PresentRectPayload::get_source_byte_count(self : PresentRectPayload) -> Int

    PresentRectPayload::get_source_padding_byte_count

    source
    fn PresentRectPayload::get_source_padding_byte_count(self : PresentRectPayload) -> Int

    PresentRectPayload::new

    source
    fn PresentRectPayload::new(rect : PixelRect, row_bytes : Int, pixels : FixedArray[Byte]) -> Result[PresentRectPayload, PresentError]

    Build a validated rectangle present payload from caller-provided RGBA rows.

    PresentRectPayload::submit_to

    source
    fn[S : Surface] PresentRectPayload::submit_to(self : PresentRectPayload, surface : S) -> Result[Unit, PresentError]

    PresentRectPayload::to_repr

    source

    Rect

    source
    pub struct Rect {
      x : Double
      y : Double
      width : Double
      height : Double
    } derive(Eq, 
    Debug    )

    2D rectangle defined by origin and size

    Rect::bottom

    source
    fn Rect::bottom(self : Rect) -> Double

    Get the bottom edge (y + height)

    Rect::contains

    source
    fn Rect::contains(self : Rect, px : Double, py : Double) -> Bool

    Check if a point is inside the rectangle

    Rect::equal

    source
    fn Rect::equal(Rect, Rect) -> Bool

    Rect::intersection

    source
    fn Rect::intersection(self : Rect, other : Rect) -> Rect?

    Return the overlapping rectangle, if both rectangles overlap with area.

    Rect::is_empty

    source
    fn Rect::is_empty(self : Rect) -> Bool

    Check whether this rectangle has no positive area.

    Rect::new

    source
    fn Rect::new(x~ : Double, y~ : Double, width~ : Double, height~ : Double) -> Rect

    Create a rectangle

    Rect::not_equal

    source
    fn Rect::not_equal(x : Rect, y : Rect) -> Bool

    Rect::right

    source
    fn Rect::right(self : Rect) -> Double

    Get the right edge (x + width)

    Rect::to_repr

    source

    RenderFrame

    source
    pub struct RenderFrame {
      canvas : Canvas
      layer_tree : LayerTree
      dirty_rect_limit : Int
    } derive(
    Debug    )

    A frame-sized drawing target with a z-ordered layer tree and a dirty-present policy. This is the small unit an event loop can submit to a Surface.

    RenderFrame::clear_dirty_regions

    source
    fn RenderFrame::clear_dirty_regions(self : RenderFrame) -> Unit

    RenderFrame::dirty_bounds

    source
    fn RenderFrame::dirty_bounds(self : RenderFrame) -> PixelRect?

    RenderFrame::dirty_present_batch

    source
    fn[S : Surface] RenderFrame::dirty_present_batch(self : RenderFrame, surface : S) -> Result[PresentBatch, PresentError]

    RenderFrame::dirty_present_plan

    source
    fn[S : Surface] RenderFrame::dirty_present_plan(self : RenderFrame, surface : S) -> DirtyPresentPlan

    RenderFrame::dirty_submit_plan

    source
    fn[S : Surface] RenderFrame::dirty_submit_plan(self : RenderFrame, surface : S) -> DirtySubmitPlan

    RenderFrame::get_canvas

    source
    fn RenderFrame::get_canvas(self : RenderFrame) -> Canvas

    RenderFrame::get_dirty_rect_limit

    source
    fn RenderFrame::get_dirty_rect_limit(self : RenderFrame) -> Int

    RenderFrame::get_height

    source
    fn RenderFrame::get_height(self : RenderFrame) -> Int

    RenderFrame::get_layer_tree

    source
    fn RenderFrame::get_layer_tree(self : RenderFrame) -> LayerTree

    RenderFrame::get_width

    source
    fn RenderFrame::get_width(self : RenderFrame) -> Int

    RenderFrame::has_dirty

    source
    fn RenderFrame::has_dirty(self : RenderFrame) -> Bool

    RenderFrame::mark_all_dirty

    source
    fn RenderFrame::mark_all_dirty(self : RenderFrame) -> Unit

    RenderFrame::mark_dirty_rect

    source
    fn RenderFrame::mark_dirty_rect(self : RenderFrame, rect : PixelRect) -> Unit

    RenderFrame::new

    source
    fn RenderFrame::new(width : Int, height : Int) -> RenderFrame

    RenderFrame::present_all_to

    source
    fn[S : Surface] RenderFrame::present_all_to(self : RenderFrame, surface : S) -> Result[Int, PresentError]

    RenderFrame::present_dirty_to

    source
    fn[S : Surface] RenderFrame::present_dirty_to(self : RenderFrame, surface : S) -> Result[Int, PresentError]

    RenderFrame::present_strategy

    source
    fn[S : Surface] RenderFrame::present_strategy(self : RenderFrame, surface : S) -> DirtyPresentStrategy

    RenderFrame::redraw_schedule

    source
    fn[S : Surface] RenderFrame::redraw_schedule(self : RenderFrame, surface : S) -> RenderFrameSchedule

    Dry-run a window redraw submission. Dirty frames reuse the regular schedule; clean frames are promoted to a full cached present so OS redraw requests can repaint without each event loop reimplementing that policy.

    RenderFrame::replace_layer

    source
    fn RenderFrame::replace_layer(self : RenderFrame, layer_index : Int, layer : Layer) -> Layer?

    Replace one frame-owned layer and invalidate the old and new layer bounds.

    RenderFrame::replace_layers

    source
    fn RenderFrame::replace_layers(self : RenderFrame, requests : Array[RenderFrameLayerReplacementRequest]) -> Bool

    Replace multiple frame-owned layers after validating every target index.

    RenderFrame::resize

    source
    fn RenderFrame::resize(self : RenderFrame, width : Int, height : Int) -> RenderFrame

    RenderFrame::resize_and_clear_layer

    source
    fn RenderFrame::resize_and_clear_layer(self : RenderFrame, layer_index : Int, width : Int, height : Int, color : Color) -> Bool

    Resize the frame and a layer-sized background cache, then clear that layer. Intended for GUI resize handlers that keep a full-frame background layer at a stable index while other layers are replaced or redrawn separately.

    RenderFrame::resize_and_clear_layers

    source
    fn RenderFrame::resize_and_clear_layers(self : RenderFrame, width : Int, height : Int, requests : Array[RenderFrameLayerClearRequest]) -> Bool

    Resize the frame and multiple layer-sized caches, then clear each layer. This validates all requested layers before mutating frame or layer state.

    RenderFrame::resize_clear_and_replace_layers

    source
    fn RenderFrame::resize_clear_and_replace_layers(self : RenderFrame, width : Int, height : Int, clear_requests : Array[RenderFrameLayerClearRequest], replacement_requests : Array[RenderFrameLayerReplacementRequest]) -> Bool

    Resize the frame, clear frame-sized layer caches, and replace redrawn layers. This validates every requested layer before mutating frame or layer state.

    RenderFrame::set_dirty_rect_limit

    source
    fn RenderFrame::set_dirty_rect_limit(self : RenderFrame, limit : Int) -> RenderFrame

    RenderFrame::submit_by_strategy_plan

    source
    fn[S : Surface] RenderFrame::submit_by_strategy_plan(self : RenderFrame, surface : S) -> RenderFrameSubmitPlan

    RenderFrame::submit_by_strategy_to

    source
    fn[S : Surface] RenderFrame::submit_by_strategy_to(self : RenderFrame, surface : S) -> Result[RenderFrameSubmitResult, PresentError]

    RenderFrame::submit_dirty_to

    source
    fn[S : Surface] RenderFrame::submit_dirty_to(self : RenderFrame, surface : S) -> Result[DirtySubmitResult, PresentError]

    RenderFrame::submit_redraw_to

    source
    fn[S : Surface] RenderFrame::submit_redraw_to(self : RenderFrame, surface : S) -> Result[RenderFrameSubmitResult, PresentError]

    RenderFrame::submit_request_by_policy

    source
    fn[S : Surface] RenderFrame::submit_request_by_policy(self : RenderFrame, surface : S, policy : RenderFrameSubmitPolicy) -> RenderFrameSubmitRequest

    RenderFrame::submit_request_to

    source
    fn[S : Surface] RenderFrame::submit_request_to(self : RenderFrame, surface : S, request : RenderFrameSubmitRequest) -> Result[RenderFrameSubmitResult, PresentError]

    RenderFrame::submit_schedule

    source
    fn[S : Surface] RenderFrame::submit_schedule(self : RenderFrame, surface : S) -> RenderFrameSchedule

    RenderFrame::submit_schedule_by_policy

    source
    fn[S : Surface] RenderFrame::submit_schedule_by_policy(self : RenderFrame, surface : S, policy : RenderFrameSubmitPolicy) -> RenderFrameSchedule

    RenderFrame::submit_scheduled_to

    source
    fn[S : Surface] RenderFrame::submit_scheduled_to(self : RenderFrame, surface : S, schedule : RenderFrameSchedule) -> Result[RenderFrameSubmitResult, PresentError]

    RenderFrame::submit_to_by_policy

    source
    fn[S : Surface] RenderFrame::submit_to_by_policy(self : RenderFrame, surface : S, policy : RenderFrameSubmitPolicy) -> Result[RenderFrameSubmitResult, PresentError]

    RenderFrame::to_repr

    source

    RenderFrameLayerClearRequest

    source
    pub struct RenderFrameLayerClearRequest {
      layer_index : Int
      color : Color
    } derive(Eq, 
    Debug    )

    Request to resize one frame-owned layer cache and clear it to a color.

    RenderFrameLayerClearRequest::equal

    source

    RenderFrameLayerClearRequest::get_color

    source

    Return the clear color for the target layer.

    RenderFrameLayerClearRequest::get_layer_index

    source

    Return the target layer index.

    RenderFrameLayerClearRequest::new

    source
    fn RenderFrameLayerClearRequest::new(layer_index : Int, color : Color) -> RenderFrameLayerClearRequest

    Create a layer clear request for a RenderFrame resize lifecycle operation.

    RenderFrameLayerClearRequest::not_equal

    source

    RenderFrameLayerClearRequest::to_repr

    source

    RenderFrameLayerReplacementRequest

    source
    pub struct RenderFrameLayerReplacementRequest {
      layer_index : Int
      layer : Layer
    } derive(
    Debug    )

    Request to replace one frame-owned layer cache.

    RenderFrameLayerReplacementRequest::get_layer

    source

    Return the replacement layer.

    RenderFrameLayerReplacementRequest::get_layer_index

    source

    Return the target layer index.

    RenderFrameLayerReplacementRequest::new

    source

    Create a layer replacement request for a RenderFrame lifecycle operation.

    RenderFrameLayerReplacementRequest::to_repr

    source

    RenderFrameSchedule

    source
    pub struct RenderFrameSchedule {
      submit_plan : RenderFrameSubmitPlan
      action : RenderFrameScheduleAction
    } derive(
    Debug    )

    Dry-run scheduling decision for submitting a RenderFrame to a Surface.

    RenderFrameSchedule::get_action

    source

    RenderFrameSchedule::get_dirty_bounds

    source
    fn RenderFrameSchedule::get_dirty_bounds(self : RenderFrameSchedule) -> PixelRect?

    RenderFrameSchedule::get_present_bounds

    source
    fn RenderFrameSchedule::get_present_bounds(self : RenderFrameSchedule) -> PixelRect?

    RenderFrameSchedule::get_present_byte_count

    source
    fn RenderFrameSchedule::get_present_byte_count(self : RenderFrameSchedule) -> Int

    RenderFrameSchedule::get_present_pixel_count

    source
    fn RenderFrameSchedule::get_present_pixel_count(self : RenderFrameSchedule) -> Int

    RenderFrameSchedule::get_present_rect_count

    source
    fn RenderFrameSchedule::get_present_rect_count(self : RenderFrameSchedule) -> Int

    RenderFrameSchedule::get_present_strategy

    source

    RenderFrameSchedule::get_state

    source

    RenderFrameSchedule::get_submit_plan

    source

    RenderFrameSchedule::has_dirty

    source
    fn RenderFrameSchedule::has_dirty(self : RenderFrameSchedule) -> Bool

    RenderFrameSchedule::needs_present

    source
    fn RenderFrameSchedule::needs_present(self : RenderFrameSchedule) -> Bool

    RenderFrameSchedule::saves_full_present_pixels

    source
    fn RenderFrameSchedule::saves_full_present_pixels(self : RenderFrameSchedule) -> Bool

    RenderFrameSchedule::should_submit

    source
    fn RenderFrameSchedule::should_submit(self : RenderFrameSchedule) -> Bool

    RenderFrameSchedule::to_repr

    source

    RenderFrameSchedule::uses_bounds_fallback

    source
    fn RenderFrameSchedule::uses_bounds_fallback(self : RenderFrameSchedule) -> Bool

    RenderFrameSchedule::was_clipped_away

    source
    fn RenderFrameSchedule::was_clipped_away(self : RenderFrameSchedule) -> Bool

    RenderFrameScheduleAction

    source
    pub(all) enum RenderFrameScheduleAction {
      Skip
      SubmitWithoutPresent
      Present
    } derive(Eq, 
    Debug    )

    Event-loop-facing action selected from a dry-run RenderFrame submit plan.

    RenderFrameScheduleAction::equal

    source

    RenderFrameScheduleAction::not_equal

    source

    RenderFrameScheduleAction::to_repr

    source

    RenderFrameSubmitPlan

    source
    pub struct RenderFrameSubmitPlan {
      dirty_submit_plan : DirtySubmitPlan
      strategy : DirtyPresentStrategy
      present_bounds : PixelRect?
      present_rect_count : Int
      present_pixel_count : Int
      present_byte_count : Int
    } derive(
    Debug    )

    Strategy-aware dry-run plan for submitting a RenderFrame to a Surface.

    RenderFrameSubmitPlan::get_dirty_bounds

    source
    fn RenderFrameSubmitPlan::get_dirty_bounds(self : RenderFrameSubmitPlan) -> PixelRect?

    RenderFrameSubmitPlan::get_dirty_submit_plan

    source
    fn RenderFrameSubmitPlan::get_dirty_submit_plan(self : RenderFrameSubmitPlan) -> DirtySubmitPlan

    RenderFrameSubmitPlan::get_present_bounds

    source
    fn RenderFrameSubmitPlan::get_present_bounds(self : RenderFrameSubmitPlan) -> PixelRect?

    RenderFrameSubmitPlan::get_present_byte_count

    source
    fn RenderFrameSubmitPlan::get_present_byte_count(self : RenderFrameSubmitPlan) -> Int

    RenderFrameSubmitPlan::get_present_pixel_count

    source
    fn RenderFrameSubmitPlan::get_present_pixel_count(self : RenderFrameSubmitPlan) -> Int

    RenderFrameSubmitPlan::get_present_rect_count

    source
    fn RenderFrameSubmitPlan::get_present_rect_count(self : RenderFrameSubmitPlan) -> Int

    RenderFrameSubmitPlan::get_present_strategy

    source

    RenderFrameSubmitPlan::get_state

    source

    RenderFrameSubmitPlan::has_dirty

    source
    fn RenderFrameSubmitPlan::has_dirty(self : RenderFrameSubmitPlan) -> Bool

    RenderFrameSubmitPlan::needs_present

    source
    fn RenderFrameSubmitPlan::needs_present(self : RenderFrameSubmitPlan) -> Bool

    RenderFrameSubmitPlan::saves_full_present_pixels

    source
    fn RenderFrameSubmitPlan::saves_full_present_pixels(self : RenderFrameSubmitPlan) -> Bool

    RenderFrameSubmitPlan::to_repr

    source

    RenderFrameSubmitPlan::uses_bounds_fallback

    source
    fn RenderFrameSubmitPlan::uses_bounds_fallback(self : RenderFrameSubmitPlan) -> Bool

    RenderFrameSubmitPlan::was_clipped_away

    source
    fn RenderFrameSubmitPlan::was_clipped_away(self : RenderFrameSubmitPlan) -> Bool

    RenderFrameSubmitPolicy

    source
    pub(all) enum RenderFrameSubmitPolicy {
      DirtyOnly
      CachedRedraw
      FullRedraw
    } derive(Eq, 
    Debug    )

    Event-loop-facing submit policy for choosing between dirty-only work, cached repaint requests, and unconditional full redraws.

    RenderFrameSubmitPolicy::equal

    source

    RenderFrameSubmitPolicy::not_equal

    source

    RenderFrameSubmitPolicy::to_repr

    source

    RenderFrameSubmitRequest

    source
    pub struct RenderFrameSubmitRequest {
      policy : RenderFrameSubmitPolicy
      schedule : RenderFrameSchedule
    } derive(
    Debug    )

    Policy intent paired with the dry-run schedule selected for one frame submit. Event loops can inspect this request, then execute the same precomputed decision without recomputing scheduling state.

    RenderFrameSubmitRequest::get_action

    source

    RenderFrameSubmitRequest::get_dirty_bounds

    source

    RenderFrameSubmitRequest::get_policy

    source

    RenderFrameSubmitRequest::get_present_bounds

    source

    RenderFrameSubmitRequest::get_present_byte_count

    source
    fn RenderFrameSubmitRequest::get_present_byte_count(self : RenderFrameSubmitRequest) -> Int

    RenderFrameSubmitRequest::get_present_pixel_count

    source
    fn RenderFrameSubmitRequest::get_present_pixel_count(self : RenderFrameSubmitRequest) -> Int

    RenderFrameSubmitRequest::get_present_rect_count

    source
    fn RenderFrameSubmitRequest::get_present_rect_count(self : RenderFrameSubmitRequest) -> Int

    RenderFrameSubmitRequest::get_present_strategy

    source

    RenderFrameSubmitRequest::get_schedule

    source

    RenderFrameSubmitRequest::get_state

    source

    RenderFrameSubmitRequest::get_submit_plan

    source

    RenderFrameSubmitRequest::has_dirty

    source

    RenderFrameSubmitRequest::needs_present

    source
    fn RenderFrameSubmitRequest::needs_present(self : RenderFrameSubmitRequest) -> Bool

    RenderFrameSubmitRequest::new

    source

    RenderFrameSubmitRequest::saves_full_present_pixels

    source
    fn RenderFrameSubmitRequest::saves_full_present_pixels(self : RenderFrameSubmitRequest) -> Bool

    RenderFrameSubmitRequest::should_submit

    source
    fn RenderFrameSubmitRequest::should_submit(self : RenderFrameSubmitRequest) -> Bool

    RenderFrameSubmitRequest::to_repr

    source

    RenderFrameSubmitRequest::uses_bounds_fallback

    source
    fn RenderFrameSubmitRequest::uses_bounds_fallback(self : RenderFrameSubmitRequest) -> Bool

    RenderFrameSubmitRequest::was_clipped_away

    source
    fn RenderFrameSubmitRequest::was_clipped_away(self : RenderFrameSubmitRequest) -> Bool

    RenderFrameSubmitResult

    source
    pub struct RenderFrameSubmitResult {
      submit_plan : RenderFrameSubmitPlan
      presented_rect_count : Int
    } derive(
    Debug    )

    Result of submitting a RenderFrame through the strategy-aware scheduler.

    RenderFrameSubmitResult::did_present

    source
    fn RenderFrameSubmitResult::did_present(self : RenderFrameSubmitResult) -> Bool

    RenderFrameSubmitResult::get_dirty_bounds

    source

    RenderFrameSubmitResult::get_present_bounds

    source
    fn RenderFrameSubmitResult::get_present_bounds(self : RenderFrameSubmitResult) -> PixelRect?

    RenderFrameSubmitResult::get_present_byte_count

    source
    fn RenderFrameSubmitResult::get_present_byte_count(self : RenderFrameSubmitResult) -> Int

    RenderFrameSubmitResult::get_present_pixel_count

    source
    fn RenderFrameSubmitResult::get_present_pixel_count(self : RenderFrameSubmitResult) -> Int

    RenderFrameSubmitResult::get_present_rect_count

    source
    fn RenderFrameSubmitResult::get_present_rect_count(self : RenderFrameSubmitResult) -> Int

    RenderFrameSubmitResult::get_present_strategy

    source

    RenderFrameSubmitResult::get_presented_rect_count

    source
    fn RenderFrameSubmitResult::get_presented_rect_count(self : RenderFrameSubmitResult) -> Int

    RenderFrameSubmitResult::get_state

    source

    RenderFrameSubmitResult::get_submit_plan

    source

    RenderFrameSubmitResult::has_dirty

    source
    fn RenderFrameSubmitResult::has_dirty(self : RenderFrameSubmitResult) -> Bool

    RenderFrameSubmitResult::needs_present

    source
    fn RenderFrameSubmitResult::needs_present(self : RenderFrameSubmitResult) -> Bool

    RenderFrameSubmitResult::saves_full_present_pixels

    source
    fn RenderFrameSubmitResult::saves_full_present_pixels(self : RenderFrameSubmitResult) -> Bool

    RenderFrameSubmitResult::to_repr

    source

    RenderFrameSubmitResult::uses_bounds_fallback

    source
    fn RenderFrameSubmitResult::uses_bounds_fallback(self : RenderFrameSubmitResult) -> Bool

    RenderFrameSubmitResult::was_clipped_away

    source
    fn RenderFrameSubmitResult::was_clipped_away(self : RenderFrameSubmitResult) -> Bool

    ScanlineRasterizer

    source
    pub struct ScanlineRasterizer {
      width : Int
      height : Int
      pixels : FixedArray[Byte]
    }

    Scanline rasterizer for vector path filling

    ScanlineRasterizer::clear

    source
    fn ScanlineRasterizer::clear(self : ScanlineRasterizer, color : Color) -> Unit

    Clear the buffer

    ScanlineRasterizer::draw_line

    source
    fn ScanlineRasterizer::draw_line(self : ScanlineRasterizer, x0 : Int, y0 : Int, x1 : Int, y1 : Int, color : Color) -> Unit

    Draw a line using Bresenham's algorithm

    ScanlineRasterizer::fill_polygon

    source
    fn ScanlineRasterizer::fill_polygon(self : ScanlineRasterizer, points : Array[(Double, Double)], color : Color) -> Unit

    Fill a convex polygon (works for any convex shape)

    ScanlineRasterizer::fill_triangle

    source
    fn ScanlineRasterizer::fill_triangle(self : ScanlineRasterizer, x0 : Double, y0 : Double, x1 : Double, y1 : Double, x2 : Double, y2 : Double, color : Color) -> Unit

    Fill a triangle using scanline algorithm

    ScanlineRasterizer::get_pixels

    source
    fn ScanlineRasterizer::get_pixels(self : ScanlineRasterizer) -> FixedArray[Byte]

    Get the pixel buffer (RGBA)

    ScanlineRasterizer::new

    source
    fn ScanlineRasterizer::new(width : Int, height : Int) -> ScanlineRasterizer

    Create a new scanline rasterizer

    Size

    source
    pub struct Size {
      width : Double
      height : Double
    } derive(Eq, 
    Debug    )

    2D size (width and height)

    Size::equal

    source
    fn Size::equal(Size, Size) -> Bool

    Size::new

    source
    fn Size::new(width~ : Double, height~ : Double) -> Size

    Size::not_equal

    source
    fn Size::not_equal(x : Size, y : Size) -> Bool

    Size::to_repr

    source

    StrokeCap

    source
    pub(all) enum StrokeCap {
      Butt
      Round
      Square
    } derive(Eq, 
    Debug    )

    Stroke cap style

    StrokeCap::equal

    source
    fn StrokeCap::equal(StrokeCap, StrokeCap) -> Bool

    StrokeCap::not_equal

    source
    fn StrokeCap::not_equal(x : StrokeCap, y : StrokeCap) -> Bool

    StrokeCap::to_repr

    source

    StrokeEndpoint

    source
    type StrokeEndpoint derive(
    Debug    )

    StrokeJoin

    source
    pub(all) enum StrokeJoin {
      Miter
      Round
      Bevel
    } derive(Eq, 
    Debug    )

    Stroke join style

    StrokeJoin::equal

    source
    fn StrokeJoin::equal(StrokeJoin, StrokeJoin) -> Bool

    StrokeJoin::not_equal

    source
    fn StrokeJoin::not_equal(x : StrokeJoin, y : StrokeJoin) -> Bool

    StrokeJoin::to_repr

    source

    StrokeJoinPoint

    source
    type StrokeJoinPoint derive(
    Debug    )

    StrokePathData

    source
    type StrokePathData derive(
    Debug    )

    Transform

    source
    pub struct Transform {
      a : Double
      b : Double
      c : Double
      d : Double
      tx : Double
      ty : Double
    } derive(Eq, 
    Debug    )

    2D affine transformation matrix | a b tx | | c d ty | | 0 0 1 |

    Transform::affine

    source
    fn Transform::affine(a~ : Double, b~ : Double, c~ : Double, d~ : Double, tx~ : Double, ty~ : Double) -> Transform

    Create an arbitrary affine transform.

    Transform::apply

    source
    fn Transform::apply(self : Transform, x : Double, y : Double) -> (Double, Double)

    Apply transform to a point

    Transform::equal

    source
    fn Transform::equal(Transform, Transform) -> Bool

    Transform::identity

    source
    fn Transform::identity() -> Transform

    Create an identity transform

    Transform::inverse

    source
    fn Transform::inverse(self : Transform) -> Transform?

    Return the inverse transform if this matrix is invertible.

    Transform::multiply

    source
    fn Transform::multiply(self : Transform, other : Transform) -> Transform

    Multiply two transforms

    Transform::not_equal

    source
    fn Transform::not_equal(x : Transform, y : Transform) -> Bool

    Transform::rotate

    source
    fn Transform::rotate(angle : Double) -> Transform

    Create a rotation transform (angle in radians)

    Transform::scale

    source
    fn Transform::scale(sx~ : Double, sy~ : Double) -> Transform

    Create a scale transform

    Transform::to_repr

    source

    Transform::translate

    source
    fn Transform::translate(tx~ : Double, ty~ : Double) -> Transform

    Create a translation transform

    Vec2

    source
    pub struct Vec2 {
      x : Double
      y : Double
    } derive(Eq, 
    Debug    )

    2D vector (same as Point but semantically different)

    Vec2::equal

    source
    fn Vec2::equal(Vec2, Vec2) -> Bool

    Vec2::new

    source
    fn Vec2::new(x~ : Double, y~ : Double) -> Vec2

    Vec2::not_equal

    source
    fn Vec2::not_equal(x : Vec2, y : Vec2) -> Bool

    Vec2::to_repr

    source

    present_pixels

    source
    fn[S : Surface] present_pixels(surface : S, width : Int, height : Int, row_bytes : Int, pixels : FixedArray[Byte]) -> Result[Unit, PresentError]

    present_pixels_rect

    source
    fn[S : Surface] present_pixels_rect(surface : S, x : Int, y : Int, width : Int, height : Int, row_bytes : Int, pixels : FixedArray[Byte]) -> Result[Unit, PresentError]

    validate_present_rect

    source
    fn validate_present_rect(surface_width : Int, surface_height : Int, x : Int, y : Int, width : Int, height : Int, row_bytes : Int, pixels : FixedArray[Byte]) -> Result[PresentRectInfo, PresentError]

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io