🥮 mooncakes.io

    svg

    Standalone SVG scene graph and renderer

    svg
    graphics
    Download zip
    Author
    Version
    0.2.3
    License
    Apache-2.0
    Repository
    Last updated
    last month
    Downloads
    37K

    #mizchi/svg

    Standalone SVG scene graph, parser, and CPU rasterizer for MoonBit. It can render SVG markup or an external SVGNode tree into an Image or any custom pixel target.

    #Install

    moon add mizchi/svg

    #Quick Start (SVG string -> Image)

    let svg = "<svg width=\"10\" height=\"10\"><rect x=\"1\" y=\"1\" width=\"8\" height=\"8\" fill=\"red\"/></svg>"
    match render_svg_to_image(svg, 16, 16) {
      Some(image) => image
      None => panic("parse failed")
    }

    #DOM Integration (external tree -> Image)

    Build an SVGNode tree from your DOM, then render:

    let node = rect("r", 2.0, 2.0, 6.0, 6.0)
    node.fill = SolidColor(Color::black())
    let doc = SVGDocument::new(node)
    let image = render_svg_document_to_image(doc, 16, 16)

    If you already have a scene graph:

    let scene = Scene::new(node)
    let image = render_svg_scene_to_image(scene, 16, 16)

    #Custom Rendering Target

    You can render into any target by providing a PixelSetter and RenderContext.

    let image = Image::new(64, 64)
    let setter : PixelSetter = { set: fn(x, y, c) { image.set_pixel(x, y, c) } }
    let ctx = RenderContext::new(setter, 64, 64)
    let doc = SVGDocument::new(rect("r", 0.0, 0.0, 10.0, 10.0))
    doc.render(ctx)

    #Main API

    • Parsing: parse_svg, parse_svg_document
    • Scene graph: SVGNode, Scene, SVGDocument
    • Rendering: RenderContext, PixelSetter, render_svg_*_to_image
    • Geometry: PathCommand, Transform, ViewBox, BoundingBox
    • Raster: raster_* (low-level drawing primitives)

    #WPT (SVG Reftests)

    This repo can run a static, DOM-independent subset of WPT SVG reftests. Tests are generated from the WPT submodule and rendered with the CPU rasterizer.

    git submodule update --init --depth 1 wpt
just wpt-svg

    You can limit generation:

    just wpt-svg --limit=50

    Notes:
    • Only .svg reftests with <link rel=\"match\"> are included.
    • Tests with scripts/animation/foreignObject/styles are skipped.
    • Many tests will fail until the renderer covers those features.
    • Comparison uses a per-channel tolerance (<=2) and allows up to 0.5% differing pixels.

    Align

    source
    pub(all) enum Align {
      None
      XMinYMin
      XMidYMin
      XMaxYMin
      XMinYMid
      XMidYMid
      XMaxYMid
      XMinYMax
      XMidYMax
      XMaxYMax
    } derive(Eq, 
    Debug    )

    preserveAspectRatio alignment values
    impl Show for Align

    AnimProperty

    source
    pub(all) enum AnimProperty {
      TranslateX(Double)
      TranslateY(Double)
      Translate(Double, Double)
      ScaleX(Double)
      ScaleY(Double)
      Scale(Double, Double)
      ScaleUniform(Double)
      Rotation(Double)
      Opacity(Double)
      FillColor(Color)
    }

    Animatable property types

    AnimatedSprite

    source
    pub(all) struct AnimatedSprite {
      sheet : SpriteSheet
      frames : Array[Int]
      current_frame : Int
      frame_duration : Double
      elapsed : Double
      looping : Bool
      playing : Bool
    }

    Animated sprite helper

    AnimatedSprite::continue_playing

    source
    fn AnimatedSprite::continue_playing(self : AnimatedSprite) -> Unit

    Continue animation

    AnimatedSprite::from_range

    source
    fn AnimatedSprite::from_range(sheet : SpriteSheet, start : Int, end : Int, frame_duration : Double) -> AnimatedSprite

    Create animation for a range of frames

    AnimatedSprite::get_current_sprite

    source
    fn AnimatedSprite::get_current_sprite(self : AnimatedSprite) -> Sprite

    Get current sprite

    AnimatedSprite::new

    source
    fn AnimatedSprite::new(sheet : SpriteSheet, frames : Array[Int], frame_duration : Double) -> AnimatedSprite

    Create an animated sprite

    AnimatedSprite::pause

    source
    fn AnimatedSprite::pause(self : AnimatedSprite) -> Unit

    Pause animation

    AnimatedSprite::play

    source
    fn AnimatedSprite::play(self : AnimatedSprite) -> Unit

    Play animation from beginning

    AnimatedSprite::set_looping

    source
    fn AnimatedSprite::set_looping(self : AnimatedSprite, looping : Bool) -> Unit

    Set looping

    AnimatedSprite::stop

    source
    fn AnimatedSprite::stop(self : AnimatedSprite) -> Unit

    Stop animation

    AnimatedSprite::update

    source
    fn AnimatedSprite::update(self : AnimatedSprite, dt : Double) -> Unit

    Update animation with delta time

    AnimationManager

    source
    pub(all) struct AnimationManager {
      tweens : Array[Tween]
    }

    Animation manager for coordinating multiple tweens

    AnimationManager::add

    source
    fn AnimationManager::add(self : AnimationManager, tween : Tween) -> Unit

    Add a new tween animation

    AnimationManager::animate_opacity

    source
    fn AnimationManager::animate_opacity(self : AnimationManager, target_id : String, opacity : Double, duration : Double, easing : Easing) -> Unit

    Create and add a simple opacity animation

    AnimationManager::animate_scale

    source
    fn AnimationManager::animate_scale(self : AnimationManager, target_id : String, scale : Double, duration : Double, easing : Easing) -> Unit

    Create and add a simple scale animation

    AnimationManager::animate_translate

    source
    fn AnimationManager::animate_translate(self : AnimationManager, target_id : String, x : Double, y : Double, duration : Double, easing : Easing) -> Unit

    Create and add a simple translate animation

    AnimationManager::cleanup

    source
    fn AnimationManager::cleanup(self : AnimationManager) -> Unit

    Remove completed animations

    AnimationManager::clear

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

    Clear all animations

    AnimationManager::is_animating

    source
    fn AnimationManager::is_animating(self : AnimationManager) -> Bool

    Check if any animations are running

    AnimationManager::new

    source

    AnimationManager::update

    source
    fn AnimationManager::update(self : AnimationManager, dt : Double, scene : Scene) -> Bool

    Update all animations with delta time Returns true if any animations are still running

    BlendMode

    source
    pub(all) enum BlendMode {
      Normal
      Multiply
      Screen
      Overlay
      Darken
      Lighten
      ColorDodge
      ColorBurn
      HardLight
      SoftLight
      Difference
      Exclusion
      Hue
      Saturation
      ColorMode
      Luminosity
    } derive(Eq, 
    Debug    )

    CSS mix-blend-mode values

    BoundingBox

    source
    pub(all) struct BoundingBox {
      min_x : Double
      min_y : Double
      max_x : Double
      max_y : Double
    }

    Bounding box for a shape

    BoundingBox::contains_point

    source
    fn BoundingBox::contains_point(self : BoundingBox, x : Double, y : Double) -> Bool

    Check if this bounding box contains a point

    BoundingBox::empty

    source
    fn BoundingBox::empty() -> BoundingBox

    BoundingBox::expand_by_point

    source
    fn BoundingBox::expand_by_point(self : BoundingBox, x : Double, y : Double) -> BoundingBox

    BoundingBox::from_rect

    source
    fn BoundingBox::from_rect(x : Double, y : Double, w : Double, h : Double) -> BoundingBox

    BoundingBox::height

    source
    fn BoundingBox::height(self : BoundingBox) -> Double

    BoundingBox::intersects

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

    Check if two bounding boxes intersect

    BoundingBox::is_empty

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

    BoundingBox::union

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

    BoundingBox::width

    source
    fn BoundingBox::width(self : BoundingBox) -> Double

    Camera

    source
    pub(all) struct Camera {
      x : Double
      y : Double
      zoom : Double
      viewport_width : Int
      viewport_height : Int
    }

    Camera for 2D scene navigation Supports pan (translation) and zoom

    Camera::get_transform

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

    Get transform matrix for this camera

    Camera::get_visible_bounds

    source
    fn Camera::get_visible_bounds(self : Camera) -> BoundingBox

    Get the world-space bounding box visible through this camera

    Camera::new

    source
    fn Camera::new(viewport_width : Int, viewport_height : Int) -> Camera

    Camera::pan

    source
    fn Camera::pan(self : Camera, dx : Double, dy : Double) -> Unit

    Move camera by delta

    Camera::screen_to_world

    source
    fn Camera::screen_to_world(self : Camera, sx : Int, sy : Int) -> (Double, Double)

    Convert screen coordinates to world coordinates

    Camera::set_position

    source
    fn Camera::set_position(self : Camera, x : Double, y : Double) -> Unit

    Set camera position

    Camera::set_zoom

    source
    fn Camera::set_zoom(self : Camera, zoom : Double) -> Unit

    Set zoom level

    Camera::world_to_screen

    source
    fn Camera::world_to_screen(self : Camera, wx : Double, wy : Double) -> (Int, Int)

    Convert world coordinates to screen coordinates

    Camera::zoom_by

    source
    fn Camera::zoom_by(self : Camera, factor : Double) -> Unit

    Zoom by factor (multiply current zoom)

    ClipPath

    source
    pub(all) struct ClipPath {
      id : String
      shape : Shape
      transform : Transform
      clip_rule : FillRule
      units : ClipPathUnits
    }

    Clip path definition

    ClipPath::contains

    source
    fn ClipPath::contains(self : ClipPath, x : Double, y : Double) -> Bool

    Check if a point is inside the clip path

    ClipPath::new

    source
    fn ClipPath::new(id : String, shape : Shape) -> ClipPath

    ClipPath::with_transform

    source
    fn ClipPath::with_transform(id : String, shape : Shape, transform : Transform) -> ClipPath

    ClipPathRegistry

    source
    pub(all) struct ClipPathRegistry {
      clips : Map[String, ClipPath]
    }

    Clip path registry for referencing by ID

    ClipPathRegistry::add

    source
    fn ClipPathRegistry::add(self : ClipPathRegistry, clip : ClipPath) -> Unit

    ClipPathRegistry::get

    source
    fn ClipPathRegistry::get(self : ClipPathRegistry, id : String) -> ClipPath?

    ClipPathRegistry::new

    source

    ClipPathUnits

    source
    pub(all) enum ClipPathUnits {
      UserSpaceOnUse
      ObjectBoundingBox
    } derive(Eq, 
    Debug    )

    Clip path units for coordinate system

    ClipRect

    source
    pub(all) struct ClipRect {
      x : Int
      y : Int
      width : Int
      height : Int
    }

    Clipping rectangle for camera/viewport

    ClipRect::contains

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

    Check if a point is inside the clip rect

    ClipRect::from_size

    source
    fn ClipRect::from_size(width : Int, height : Int) -> ClipRect

    ClipRect::new

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

    ClipRect::to_bbox

    source
    fn ClipRect::to_bbox(self : ClipRect) -> BoundingBox

    Convert to BoundingBox

    Color

    source
    pub(all) struct Color {
      r : Int
      g : Int
      b : Int
      a : Int
    }

    RGB Color (0-255 range)

    Color::black

    source
    fn Color::black() -> Color

    Color::is_transparent

    source
    fn Color::is_transparent(self : Color) -> Bool

    Color::rgb

    source
    fn Color::rgb(r : Int, g : Int, b : Int) -> Color

    Color::rgba

    source
    fn Color::rgba(r : Int, g : Int, b : Int, a : Int) -> Color

    Color::transparent

    source
    fn Color::transparent() -> Color

    Color::white

    source
    fn Color::white() -> Color

    DefsRegistry

    source
    pub(all) struct DefsRegistry {
      elements : Map[String, SVGNode]
    }

    Registry for reusable elements defined in

    DefsRegistry::add

    source
    fn DefsRegistry::add(self : DefsRegistry, id : String, node : SVGNode) -> Unit

    DefsRegistry::get

    source
    fn DefsRegistry::get(self : DefsRegistry, id : String) -> SVGNode?

    DefsRegistry::new

    source

    DominantBaseline

    source
    pub(all) enum DominantBaseline {
      Auto
      TextTop
      Hanging
      Middle
      Central
      TextBottom
      Alphabetic
      Ideographic
    }

    Dominant baseline (vertical alignment)

    Easing

    source
    pub(all) enum Easing {
      Linear
      EaseIn
      EaseOut
      EaseInOut
      EaseInCubic
      EaseOutCubic
      EaseInOutCubic
    } derive(Eq, 
    Debug    )

    Easing functions for smooth animations

    Easing::apply

    source
    fn Easing::apply(self : Easing, t : Double) -> Double

    Apply easing function to a normalized time (0.0 to 1.0)

    EmitterConfig

    source
    pub(all) struct EmitterConfig {
      emit_rate : Double
      life_min : Double
      life_max : Double
      speed_min : Double
      speed_max : Double
      angle_min : Double
      angle_max : Double
      size_start : Double
      size_end : Double
      color_start : Color
      color_end : Color
      gravity_x : Double
      gravity_y : Double
    }

    Particle emitter configuration

    EmitterConfig::default

    source
    fn EmitterConfig::default() -> EmitterConfig

    EventHandler

    source
    pub(all) struct EventHandler {
      call : (PointerEvent) -> Unit
    }

    Event handler type

    EventListener

    source
    pub(all) struct EventListener {
      event_type : EventType
      handler : EventHandler
    }

    Event listener entry

    EventManager

    source
    pub(all) struct EventManager {
      listeners : Map[String, Array[EventListener]]
      hovered_node : String?
      dragging_node : String?
      drag_start_x : Double
      drag_start_y : Double
    }

    Event manager for handling input events

    EventManager::dispatch_click

    source
    fn EventManager::dispatch_click(self : EventManager, x : Double, y : Double, button : Int, scene : Scene) -> Unit

    Dispatch a click event at coordinates

    EventManager::dispatch_mouse_down

    source
    fn EventManager::dispatch_mouse_down(self : EventManager, x : Double, y : Double, button : Int, scene : Scene) -> Unit

    Dispatch mouse down event

    EventManager::dispatch_mouse_move

    source
    fn EventManager::dispatch_mouse_move(self : EventManager, x : Double, y : Double, scene : Scene) -> Unit

    Dispatch mouse move event (handles hover and drag)

    EventManager::dispatch_mouse_up

    source
    fn EventManager::dispatch_mouse_up(self : EventManager, x : Double, y : Double, button : Int, scene : Scene) -> Unit

    Dispatch mouse up event

    EventManager::new

    source

    EventManager::off_all

    source
    fn EventManager::off_all(self : EventManager, node_id : String) -> Unit

    Remove all listeners for a node

    EventManager::on

    source
    fn EventManager::on(self : EventManager, node_id : String, event_type : EventType, handler : EventHandler) -> Unit

    Register an event listener for a node

    EventType

    source
    pub(all) enum EventType {
      Click
      MouseDown
      MouseUp
      MouseMove
      MouseEnter
      MouseLeave
      DragStart
      DragMove
      DragEnd
    } derive(Eq, 
    Debug    )

    Event types

    FillRule

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

    Fill rule for paths and polygons
    impl Show for FillRule

    Filter

    source
    pub(all) enum Filter {
      Blur(Double)
      DropShadow(Double, Double, Double, Color)
      Brightness(Double)
      Contrast(Double)
      Grayscale(Double)
      Sepia(Double)
      HueRotate(Double)
      Invert(Double)
      Saturate(Double)
      ColorMatrix(FixedArray[Double])
    }

    Filter types

    FontStyle

    source
    pub(all) enum FontStyle {
      NormalStyle
      Italic
      Oblique
    }

    Font style

    FontWeight

    source
    pub(all) enum FontWeight {
      Normal
      Bold
      Lighter
      Bolder
      Weight(Int)
    }

    Font weight

    Gradient

    source
    pub(all) enum Gradient {
      Linear(LinearGradient)
      Radial(RadialGradient)
    }

    Gradient definitions

    GradientRegistry

    source
    pub(all) struct GradientRegistry {
      gradients : Map[String, Gradient]
    }

    Gradient registry

    GradientRegistry::add

    source
    fn GradientRegistry::add(self : GradientRegistry, id : String, gradient : Gradient) -> Unit

    GradientRegistry::get

    source
    fn GradientRegistry::get(self : GradientRegistry, id : String) -> Gradient?

    GradientRegistry::new

    source

    GradientStop

    source
    pub(all) struct GradientStop {
      offset : Double
      color : Color
    }

    Gradient stop (position 0.0-1.0 and color)

    GradientUnits

    source
    pub(all) enum GradientUnits {
      UserSpaceOnUse
      ObjectBoundingBox
    } derive(Eq, 
    Debug    )

    Gradient units coordinate space

    Image

    source
    pub(all) struct Image {
      width : Int
      height : Int
      pixels : Array[Color]
    }

    Image data (RGBA pixels)

    Image::apply_blur_in_place

    source
    fn Image::apply_blur_in_place(self : Image, radius : Int) -> Unit

    Apply blur filter in place

    Image::apply_brightness_in_place

    source
    fn Image::apply_brightness_in_place(self : Image, factor : Double) -> Unit

    Apply brightness filter in place

    Image::apply_color_matrix_in_place

    source
    fn Image::apply_color_matrix_in_place(self : Image, matrix : FixedArray[Double]) -> Unit

    Apply color matrix filter in place

    Image::apply_contrast_in_place

    source
    fn Image::apply_contrast_in_place(self : Image, factor : Double) -> Unit

    Apply contrast filter in place

    Image::apply_filter

    source
    fn Image::apply_filter(self : Image, filter : Filter) -> Image

    Apply a filter and return a new image

    Image::apply_grayscale_in_place

    source
    fn Image::apply_grayscale_in_place(self : Image, amount : Double) -> Unit

    Apply grayscale filter in place

    Image::apply_hue_rotate_in_place

    source
    fn Image::apply_hue_rotate_in_place(self : Image, angle_degrees : Double) -> Unit

    Apply hue rotate filter in place

    Image::apply_invert_in_place

    source
    fn Image::apply_invert_in_place(self : Image, amount : Double) -> Unit

    Apply invert filter in place

    Image::apply_saturate_in_place

    source
    fn Image::apply_saturate_in_place(self : Image, factor : Double) -> Unit

    Apply saturate filter in place

    Image::apply_sepia_in_place

    source
    fn Image::apply_sepia_in_place(self : Image, amount : Double) -> Unit

    Apply sepia filter in place

    Image::clear

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

    Clear image to transparent

    Image::clone

    source
    fn Image::clone(self : Image) -> Image

    Clone the image

    Image::fill_horizontal_line

    source
    fn Image::fill_horizontal_line(self : Image, x1 : Int, x2 : Int, y : Int, color : Color) -> Unit

    Fill a horizontal line (optimized for scanline rendering) x1 and x2 are inclusive, caller should ensure y is valid

    Image::fill_rect

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

    Fill a rectangle region

    Image::filled

    source
    fn Image::filled(width : Int, height : Int, color : Color) -> Image

    Create an image filled with a color

    Image::flip_horizontal

    source
    fn Image::flip_horizontal(self : Image) -> Image

    Flip image horizontally

    Image::flip_vertical

    source
    fn Image::flip_vertical(self : Image) -> Image

    Flip image vertically

    Image::get_pixel

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

    Get pixel at coordinates

    Image::new

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

    Create a new image with specified dimensions

    Image::rotate_90_ccw

    source
    fn Image::rotate_90_ccw(self : Image) -> Image

    Rotate image 90 degrees counter-clockwise

    Image::rotate_90_cw

    source
    fn Image::rotate_90_cw(self : Image) -> Image

    Rotate image 90 degrees clockwise

    Image::set_pixel

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

    Set pixel at coordinates

    Image::set_pixel_unchecked

    source
    fn Image::set_pixel_unchecked(self : Image, x : Int, y : Int, color : Color) -> Unit

    Set pixel without bounds checking (caller must ensure valid coordinates)

    Image::sub_image

    source
    fn Image::sub_image(self : Image, x : Int, y : Int, w : Int, h : Int) -> Image

    Create a sub-image (crop)

    Isolation

    source
    pub(all) enum Isolation {
      Auto
      Isolate
    } derive(Eq, 
    Debug    )

    CSS isolation values

    LineCap

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

    impl Show for LineCap

    LineJoin

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

    impl Show for LineJoin

    LinearGradient

    source
    pub(all) struct LinearGradient {
      x1 : Double
      y1 : Double
      x2 : Double
      y2 : Double
      stops : Array[GradientStop]
      spread_method : SpreadMethod
      units : GradientUnits
      transform : Transform
    }

    Linear gradient definition

    LinearGradient::build_lut

    source
    fn LinearGradient::build_lut(self : LinearGradient, size : Int) -> Array[Color]

    Build a lookup table for fast gradient color sampling Returns an array of colors for t values from 0.0 to 1.0

    LinearGradient::color_at

    source
    fn LinearGradient::color_at(self : LinearGradient, t : Double) -> Color

    Interpolate color at position t (0.0-1.0)

    LinearGradient::horizontal

    source
    fn LinearGradient::horizontal(start_color : Color, end_color : Color) -> LinearGradient

    Simple horizontal gradient (left to right)

    LinearGradient::new

    source
    fn LinearGradient::new(x1 : Double, y1 : Double, x2 : Double, y2 : Double, stops : Array[GradientStop]) -> LinearGradient

    LinearGradient::vertical

    source
    fn LinearGradient::vertical(start_color : Color, end_color : Color) -> LinearGradient

    Simple vertical gradient (top to bottom)

    MarkedLine

    source
    pub(all) struct MarkedLine {
      points : Array[(Double, Double)]
      marker_start : String?
      marker_mid : String?
      marker_end : String?
    }

    Line with markers

    MarkedLine::get_angle_at

    source
    fn MarkedLine::get_angle_at(self : MarkedLine, index : Int) -> Double

    Get angle at a point on the line

    MarkedLine::new

    source
    fn MarkedLine::new(points : Array[(Double, Double)]) -> MarkedLine

    MarkedLine::with_markers

    source
    fn MarkedLine::with_markers(points : Array[(Double, Double)], start : String?, mid : String?, end : String?) -> MarkedLine

    Marker

    source
    pub(all) struct Marker {
      id : String
      content : SVGNode
      ref_x : Double
      ref_y : Double
      marker_width : Double
      marker_height : Double
      orient : MarkerOrient
      marker_units : MarkerUnits
      view_box : ViewBox?
      preserve_aspect_ratio : PreserveAspectRatio
      clip_overflow : Bool
    }

    Marker definition (for line endpoints)

    Marker::arrow

    source
    fn Marker::arrow(id : String) -> Marker

    Marker::dot

    source
    fn Marker::dot(id : String, radius : Double) -> Marker

    Marker::get_transform

    source
    fn Marker::get_transform(self : Marker, x : Double, y : Double, angle : Double, stroke_width : Double) -> Transform

    Get transform for marker at a point with given angle

    Marker::new

    source
    fn Marker::new(id : String, content : SVGNode) -> Marker

    MarkerOrient

    source
    pub(all) enum MarkerOrient {
      Auto
      AutoStartReverse
      Angle(Double)
    }

    MarkerRegistry

    source
    pub(all) struct MarkerRegistry {
      markers : Map[String, Marker]
    }

    Marker registry

    MarkerRegistry::add

    source
    fn MarkerRegistry::add(self : MarkerRegistry, marker : Marker) -> Unit

    MarkerRegistry::get

    source
    fn MarkerRegistry::get(self : MarkerRegistry, id : String) -> Marker?

    MarkerRegistry::new

    source

    MarkerUnits

    source
    pub(all) enum MarkerUnits {
      StrokeWidth
      UserSpaceOnUse_
    }

    Mask

    source
    pub(all) struct Mask {
      id : String
      content : Array[SVGNode]
      x : Double
      y : Double
      width : Double
      height : Double
      x_is_percent : Bool
      y_is_percent : Bool
      width_is_percent : Bool
      height_is_percent : Bool
      mask_units : MaskUnits
      mask_content_units : MaskUnits
      mask_type : MaskType
    }

    Mask definition for transparency masking

    Mask::get_mask_bounds

    source
    fn Mask::get_mask_bounds(self : Mask, target : BoundingBox) -> BoundingBox

    Get the mask region bounds for a given target bounds

    Mask::new

    source
    fn Mask::new(id : String, content : Array[SVGNode]) -> Mask

    Mask::with_bounds

    source
    fn Mask::with_bounds(id : String, content : Array[SVGNode], x : Double, y : Double, width : Double, height : Double) -> Mask

    MaskRegistry

    source
    pub(all) struct MaskRegistry {
      masks : Map[String, Mask]
    }

    Mask registry for referencing by ID

    MaskRegistry::add

    source
    fn MaskRegistry::add(self : MaskRegistry, mask : Mask) -> Unit

    MaskRegistry::get

    source
    fn MaskRegistry::get(self : MaskRegistry, id : String) -> Mask?

    MaskRegistry::new

    source

    MaskType

    source
    pub(all) enum MaskType {
      Luminance
      Alpha
    } derive(Eq, 
    Debug    )

    Mask type - how mask values are interpreted
    impl Show for MaskType

    MaskUnits

    source
    pub(all) enum MaskUnits {
      UserSpaceOnUse
      ObjectBoundingBox
    } derive(Eq, 
    Debug    )

    Mask content units

    MeetOrSlice

    source
    pub(all) enum MeetOrSlice {
      Meet
      Slice
    } derive(Eq, 
    Debug    )

    preserveAspectRatio meet/slice
    impl Show for MeetOrSlice

    ObjectPool

    source
    pub(all) struct ObjectPool[T] {
      available : Array[T]
      factory : () -> T
      reset : (T) -> Unit
    }

    Generic object pool for reusing objects

    ObjectPool::acquire

    source
    fn[T] ObjectPool::acquire(self : ObjectPool[T]) -> T

    Acquire an object from the pool

    ObjectPool::available_count

    source
    fn[T] ObjectPool::available_count(self : ObjectPool[T]) -> Int

    Get the number of available objects

    ObjectPool::new

    source
    fn[T] ObjectPool::new(factory : () -> T, reset : (T) -> Unit, initial_size : Int) -> ObjectPool[T]

    ObjectPool::release

    source
    fn[T] ObjectPool::release(self : ObjectPool[T], obj : T) -> Unit

    Release an object back to the pool

    Paint

    source
    pub(all) enum Paint {
      None
      SolidColor(Color)
      LinearGrad(LinearGradient)
      RadialGrad(RadialGradient)
      CurrentColor
      PaintServerRef(String, PaintFallback)
    }

    Paint style (fill or stroke)

    PaintFallback

    source
    pub(all) enum PaintFallback {
      NoPaint
      SolidColor(Color)
      CurrentColor
    }

    Paint style (fill or stroke)

    PaintOrder

    source
    pub(all) struct PaintOrder {
      order : Array[PaintOrderItem]
    } derive(Eq, 
    Debug    )

    Paint order specification (SVG 2.0)

    PaintOrder::default

    source
    fn PaintOrder::default() -> PaintOrder

    PaintOrderItem

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

    Paint order items (SVG 2.0)

    Particle

    source
    pub(all) struct Particle {
      x : Double
      y : Double
      vx : Double
      vy : Double
      life : Double
      max_life : Double
      size : Double
      color : Color
      active : Bool
    }

    Single particle state

    Particle::new

    source
    fn Particle::new() -> Particle

    ParticleEmitter

    source
    pub(all) struct ParticleEmitter {
      x : Double
      y : Double
      config : EmitterConfig
      particles : Array[Particle]
      emit_accumulator : Double
      active : Bool
    }

    Particle emitter

    ParticleEmitter::active_count

    source
    fn ParticleEmitter::active_count(self : ParticleEmitter) -> Int

    Get active particle count

    ParticleEmitter::new

    source
    fn ParticleEmitter::new(x : Double, y : Double, config : EmitterConfig, max_particles : Int) -> ParticleEmitter

    ParticleEmitter::update

    source
    fn ParticleEmitter::update(self : ParticleEmitter, dt : Double) -> Unit

    Update particles with delta time

    PathCommand

    source
    pub(all) enum PathCommand {
      MoveTo(Double, Double)
      LineTo(Double, Double)
      HorizontalLineTo(Double)
      VerticalLineTo(Double)
      CurveTo(Double, Double, Double, Double, Double, Double)
      SmoothCurveTo(Double, Double, Double, Double)
      QuadraticCurveTo(Double, Double, Double, Double)
      SmoothQuadraticCurveTo(Double, Double)
      ArcTo(Double, Double, Double, Bool, Bool, Double, Double)
      ClosePath
      MoveToRel(Double, Double)
      LineToRel(Double, Double)
      HorizontalLineToRel(Double)
      VerticalLineToRel(Double)
      CurveToRel(Double, Double, Double, Double, Double, Double)
      SmoothCurveToRel(Double, Double, Double, Double)
      QuadraticCurveToRel(Double, Double, Double, Double)
      SmoothQuadraticCurveToRel(Double, Double)
      ArcToRel(Double, Double, Double, Bool, Bool, Double, Double)
    } derive(
    Debug    )

    SVG path commands (full SVG 1.1 spec)

    PathFollower

    source
    pub(all) struct PathFollower {
      path : Array[PathCommand]
      polyline : Array[(Double, Double)]
      lengths : Array[Double]
      total_length : Double
      progress : Double
      loop_anim : Bool
    }

    Path follower for animating along a path

    PathFollower::get_position

    source
    fn PathFollower::get_position(self : PathFollower) -> (Double, Double)

    Get position at current progress

    PathFollower::new

    source
    fn PathFollower::new(path_data : String) -> PathFollower

    PathFollower::update

    source
    fn PathFollower::update(self : PathFollower, dt : Double, speed : Double) -> Bool

    Update progress with delta time and speed

    Pattern

    source
    pub(all) struct Pattern {
      id : String
      width : Double
      height : Double
      content : Array[SVGNode]
      pattern_units : PatternUnits
      pattern_content_units : PatternUnits
      transform : Transform
      view_box : ViewBox?
      preserve_aspect_ratio : PreserveAspectRatio
    }

    Pattern definition for fills

    Pattern::get_color_at

    source
    fn Pattern::get_color_at(self : Pattern, x : Double, y : Double, bbox : BoundingBox) -> Color?

    Get pattern color at a point (simplified - returns first solid color found)

    Pattern::new

    source
    fn Pattern::new(id : String, width : Double, height : Double, content : Array[SVGNode]) -> Pattern

    PatternRegistry

    source
    pub(all) struct PatternRegistry {
      patterns : Map[String, Pattern]
    }

    Pattern registry

    PatternRegistry::add

    source
    fn PatternRegistry::add(self : PatternRegistry, pattern : Pattern) -> Unit

    PatternRegistry::get

    source
    fn PatternRegistry::get(self : PatternRegistry, id : String) -> Pattern?

    PatternRegistry::new

    source

    PatternUnits

    source
    pub(all) enum PatternUnits {
      UserSpaceOnUse
      ObjectBoundingBox
    }

    PixelSetter

    source
    pub(all) struct PixelSetter {
      set : (Int, Int, Color) -> Unit
    }

    Pixel setter callback type (x, y, color) -> Unit

    PixelSetter::pixel

    source
    fn PixelSetter::pixel(self : PixelSetter, x : Int, y : Int, color : Color) -> Unit

    Draw a single pixel

    PixelSetter::with_clip

    source
    fn PixelSetter::with_clip(self : PixelSetter, clip : ClipRect) -> PixelSetter

    Create a clipped pixel setter that only draws within the clip rect

    PixelSetter::with_clip_and_offset

    source
    fn PixelSetter::with_clip_and_offset(self : PixelSetter, clip : ClipRect, offset_x : Int, offset_y : Int) -> PixelSetter

    Create a clipped pixel setter with offset (for camera translation)

    PointerEvent

    source
    pub(all) struct PointerEvent {
      x : Double
      y : Double
      button : Int
      target : String
      propagation_stopped : Bool
    }

    Mouse/pointer event data

    PointerEvent::new

    source
    fn PointerEvent::new(x : Double, y : Double, button : Int, target : String) -> PointerEvent

    PointerEvent::stop_propagation

    source
    fn PointerEvent::stop_propagation(self : PointerEvent) -> Unit

    Stop event propagation (prevent bubbling)

    PreserveAspectRatio

    source
    pub(all) struct PreserveAspectRatio {
      align : Align
      meet_or_slice : MeetOrSlice
    }

    Complete preserveAspectRatio setting

    PreserveAspectRatio::default

    source

    RadialGradient

    source
    pub(all) struct RadialGradient {
      cx : Double
      cy : Double
      fx : Double
      fy : Double
      r : Double
      stops : Array[GradientStop]
      spread_method : SpreadMethod
      units : GradientUnits
      transform : Transform
    }

    Radial gradient definition

    RadialGradient::build_lut

    source
    fn RadialGradient::build_lut(self : RadialGradient, size : Int) -> Array[Color]

    Build a lookup table for fast radial gradient color sampling

    RadialGradient::color_at

    source
    fn RadialGradient::color_at(self : RadialGradient, px : Double, py : Double, width : Double, height : Double) -> Color

    Get color at a point (px, py) relative to the gradient bounds

    RadialGradient::new

    source
    fn RadialGradient::new(cx : Double, cy : Double, r : Double, stops : Array[GradientStop]) -> RadialGradient

    RenderContext

    source
    pub(all) struct RenderContext {
      setter : PixelSetter
      width : Int
      height : Int
      flatness : Double
      clip : ClipRect?
      text_to_paths : (Int, Double) -> (Array[PathCommand], Double)?
    }

    Render context for drawing

    RenderContext::for_camera

    source
    fn RenderContext::for_camera(setter : PixelSetter, camera : Camera) -> RenderContext

    Create a RenderContext for a camera

    RenderContext::new

    source
    fn RenderContext::new(setter : PixelSetter, width : Int, height : Int) -> RenderContext

    Create a RenderContext with default settings

    RenderContext::with_clip

    source
    fn RenderContext::with_clip(setter : PixelSetter, width : Int, height : Int, clip : ClipRect) -> RenderContext

    Create a RenderContext with clipping

    RenderContext::with_font

    source
    fn RenderContext::with_font(setter : PixelSetter, width : Int, height : Int, text_to_paths : (Int, Double) -> (Array[PathCommand], Double)) -> RenderContext

    Create a RenderContext with font callback for text rendering

    SVGDocument

    source
    pub(all) struct SVGDocument {
      root : SVGNode
      symbols : SymbolRegistry
      clips : ClipPathRegistry
      masks : MaskRegistry
      patterns : PatternRegistry
      gradients : GradientRegistry
      markers : MarkerRegistry
    }

    Parsed SVG document with reusable resources

    SVGDocument::new

    source
    fn SVGDocument::new(root : SVGNode) -> SVGDocument

    SVGDocument::render

    source
    fn SVGDocument::render(self : SVGDocument, ctx : RenderContext) -> Unit

    Render a parsed SVG document with registered resources

    SVGNode

    source
    pub(all) struct SVGNode {
      id : String
      shape : Shape
      transform : Transform
      view_box : ViewBox?
      viewport_width : Double?
      viewport_height : Double?
      preserve_aspect_ratio : PreserveAspectRatio
      preserve_aspect_ratio_is_set : Bool
      fill : Paint
      fill_is_set : Bool
      color : Color?
      color_is_set : Bool
      paint_order : PaintOrder
      fill_rule : FillRule
      fill_opacity : Double
      stroke : StrokeStyle
      stroke_paint_is_set : Bool
      stroke_width_is_set : Bool
      stroke_opacity : Double
      opacity : Double
      marker_start : String?
      marker_start_is_set : Bool
      marker_mid : String?
      marker_mid_is_set : Bool
      marker_end : String?
      marker_end_is_set : Bool
      z_index : Int
      node_dirty : Bool
      prev_bounds : BoundingBox?
      filters : Array[Filter]
      mask_id : String?
      clip_path_id : String?
      clip_overflow : Bool
      children : Array[SVGNode]
    }

    SVG node (element in the scene graph)

    SVGNode::add_filter

    source
    fn SVGNode::add_filter(self : SVGNode, filter : Filter) -> Unit

    Add a filter to the node

    SVGNode::clear_clip_path

    source
    fn SVGNode::clear_clip_path(self : SVGNode) -> Unit

    Clear clip path reference

    SVGNode::clear_dirty

    source
    fn SVGNode::clear_dirty(self : SVGNode) -> Unit

    Clear the dirty flag

    SVGNode::clear_filters

    source
    fn SVGNode::clear_filters(self : SVGNode) -> Unit

    Clear all filters from the node

    SVGNode::clear_mask

    source
    fn SVGNode::clear_mask(self : SVGNode) -> Unit

    Clear mask reference

    SVGNode::clone

    source
    fn SVGNode::clone(self : SVGNode) -> SVGNode

    Clone an SVGNode (shallow clone of children)

    SVGNode::collides_with

    source
    fn SVGNode::collides_with(self : SVGNode, other : SVGNode) -> Bool

    Check collision between two SVGNodes (considering transforms)

    SVGNode::hit_test

    source
    fn SVGNode::hit_test(self : SVGNode, px : Double, py : Double) -> Bool

    Hit test an SVGNode at a point (in world coordinates) Returns true if the point is inside the node's shape

    SVGNode::hit_test_all

    source
    fn SVGNode::hit_test_all(self : SVGNode, px : Double, py : Double) -> Array[SVGNode]

    Find all nodes at a point (recursive, returns in front-to-back order)

    SVGNode::mark_dirty

    source
    fn SVGNode::mark_dirty(self : SVGNode) -> Unit

    Mark a node as dirty (needs re-render)

    SVGNode::new

    source
    fn SVGNode::new(shape : Shape) -> SVGNode

    SVGNode::set_clip_path

    source
    fn SVGNode::set_clip_path(self : SVGNode, clip_path_id : String) -> Unit

    Set clip path reference by ID

    SVGNode::set_mask

    source
    fn SVGNode::set_mask(self : SVGNode, mask_id : String) -> Unit

    Set mask reference by ID

    Scene

    source
    pub(all) struct Scene {
      root : SVGNode
      dirty : Bool
    }

    Scene represents a renderable SVG scene with optimization support

    Scene::add_child

    source
    fn Scene::add_child(self : Scene, parent_id : String, child : SVGNode) -> Bool

    Add a child to a node by parent ID

    Scene::bring_to_front

    source
    fn Scene::bring_to_front(self : Scene, id : String) -> Bool

    Bring a node to front (set z_index higher than all siblings)

    Scene::clear_all_dirty

    source
    fn Scene::clear_all_dirty(self : Scene) -> Unit

    Clear all dirty flags in the scene

    Scene::clear_dirty

    source
    fn Scene::clear_dirty(self : Scene) -> Unit

    Clear the dirty flag

    Scene::empty

    source
    fn Scene::empty() -> Scene

    Create an empty scene with a group root

    Scene::find_node

    source
    fn Scene::find_node(self : Scene, id : String) -> SVGNode?

    Find a node by ID

    Scene::get_bounds

    source
    fn Scene::get_bounds(self : Scene) -> BoundingBox

    Compute the bounding box of the entire scene

    Scene::get_dirty_region

    source
    fn Scene::get_dirty_region(self : Scene) -> BoundingBox

    Compute the dirty region (union of all dirty node bounds)

    Scene::get_root

    source
    fn Scene::get_root(self : Scene) -> SVGNode

    Get the root node

    Scene::is_dirty

    source
    fn Scene::is_dirty(self : Scene) -> Bool

    Check if scene needs re-render

    Scene::mark_dirty

    source
    fn Scene::mark_dirty(self : Scene) -> Unit

    Mark the scene as dirty (needs re-render)

    Scene::mark_node_dirty

    source
    fn Scene::mark_node_dirty(self : Scene, id : String) -> Bool

    Mark a node and its ancestors as dirty

    Scene::new

    source
    fn Scene::new(root : SVGNode) -> Scene

    Create a new scene from a root SVGNode

    Scene::remove_node

    source
    fn Scene::remove_node(self : Scene, id : String) -> Bool

    Remove a node by ID

    Scene::render

    source
    fn Scene::render(self : Scene, ctx : RenderContext) -> Unit

    Render the scene to a pixel setter

    Scene::render_dirty

    source
    fn Scene::render_dirty(self : Scene, ctx : RenderContext) -> BoundingBox

    Render only nodes that intersect with the dirty region

    Scene::render_with_camera

    source
    fn Scene::render_with_camera(self : Scene, ctx : RenderContext, camera : Camera) -> Unit

    Render the scene with a camera transform

    Scene::render_with_viewbox

    source
    fn Scene::render_with_viewbox(self : Scene, ctx : RenderContext, viewbox : ViewBox, preserve_aspect_ratio : PreserveAspectRatio) -> Unit

    Render the scene with viewBox coordinate mapping

    Scene::render_with_viewbox_and_camera

    source
    fn Scene::render_with_viewbox_and_camera(self : Scene, ctx : RenderContext, viewbox : ViewBox, preserve_aspect_ratio : PreserveAspectRatio, camera : Camera) -> Unit

    Render the scene with both viewBox and camera

    Scene::send_to_back

    source
    fn Scene::send_to_back(self : Scene, id : String) -> Bool

    Send a node to back (set z_index lower than all siblings)

    Scene::set_z_index

    source
    fn Scene::set_z_index(self : Scene, id : String, z_index : Int) -> Bool

    Set z_index of a node by ID

    Scene::update_node

    source
    fn Scene::update_node(self : Scene, id : String, updater : (SVGNode) -> SVGNode) -> Bool

    Update a node by ID (returns true if found and updated)

    Shape

    source
    pub(all) enum Shape {
      Rect(x~ : Double, y~ : Double, width~ : Double, height~ : Double, rx~ : Double, ry~ : Double)
      Circle(cx~ : Double, cy~ : Double, r~ : Double)
      Ellipse(cx~ : Double, cy~ : Double, rx~ : Double, ry~ : Double)
      Line(x1~ : Double, y1~ : Double, x2~ : Double, y2~ : Double)
      Polyline(points~ : Array[(Double, Double)])
      Polygon(points~ : Array[(Double, Double)])
      Path(commands~ : Array[PathCommand])
      Text(x~ : Double, y~ : Double, text~ : String, font_size~ : Double)
      Image(x~ : Double, y~ : Double, width~ : Double, height~ : Double, href~ : String)
      Group
    } derive(
    Debug    )

    SVG shape primitives

    SimpleRNG

    source
    pub(all) struct SimpleRNG {
      state : Int
    }

    Simple pseudo-random number generator

    SimpleRNG::new

    source
    fn SimpleRNG::new(seed : Int) -> SimpleRNG

    SimpleRNG::next

    source
    fn SimpleRNG::next(self : SimpleRNG) -> Double

    SimpleRNG::range

    source
    fn SimpleRNG::range(self : SimpleRNG, min : Double, max : Double) -> Double

    SpreadMethod

    source
    pub(all) enum SpreadMethod {
      Pad
      Repeat
      Reflect
    } derive(Eq, 
    Debug    )

    How gradient extends beyond its bounds

    Sprite

    source
    pub(all) struct Sprite {
      image : Image
      x : Int
      y : Int
      width : Int
      height : Int
    }

    Sprite definition (sub-region of an image)

    Sprite::from_image

    source
    fn Sprite::from_image(image : Image) -> Sprite

    Create a sprite from the entire image

    Sprite::get_pixel

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

    Get pixel from sprite (local coordinates)

    Sprite::new

    source
    fn Sprite::new(image : Image, x : Int, y : Int, width : Int, height : Int) -> Sprite

    Create a sprite from an image region

    SpriteSheet

    source
    pub(all) struct SpriteSheet {
      image : Image
      tile_width : Int
      tile_height : Int
      columns : Int
      rows : Int
    }

    Sprite sheet for animations

    SpriteSheet::get_sprite

    source
    fn SpriteSheet::get_sprite(self : SpriteSheet, col : Int, row : Int) -> Sprite

    Get sprite at grid position

    SpriteSheet::get_sprite_by_index

    source
    fn SpriteSheet::get_sprite_by_index(self : SpriteSheet, index : Int) -> Sprite

    Get sprite by index (left-to-right, top-to-bottom)

    SpriteSheet::new

    source
    fn SpriteSheet::new(image : Image, tile_width : Int, tile_height : Int) -> SpriteSheet

    Create a sprite sheet from an image

    SpriteSheet::sprite_count

    source
    fn SpriteSheet::sprite_count(self : SpriteSheet) -> Int

    Total number of sprites in the sheet

    StrokeStyle

    source
    pub(all) struct StrokeStyle {
      paint : Paint
      width : Double
      linecap : LineCap
      linejoin : LineJoin
      miterlimit : Double
      dasharray : Array[Double]?
      dashoffset : Double
    }

    Stroke properties

    StrokeStyle::default

    source
    fn StrokeStyle::default() -> StrokeStyle

    Symbol

    source
    pub(all) struct Symbol {
      id : String
      content : SVGNode
      view_box : ViewBox?
      width : Double?
      height : Double?
      preserve_aspect_ratio : PreserveAspectRatio
      display_none : Bool
    }

    Symbol definition (reusable graphic)

    Symbol::new

    source
    fn Symbol::new(id : String, content : SVGNode) -> Symbol

    Symbol::with_viewbox

    source
    fn Symbol::with_viewbox(id : String, content : SVGNode, view_box : ViewBox) -> Symbol

    SymbolRegistry

    source
    pub(all) struct SymbolRegistry {
      symbols : Map[String, Symbol]
    }

    Symbol registry

    SymbolRegistry::add

    source
    fn SymbolRegistry::add(self : SymbolRegistry, symbol : Symbol) -> Unit

    SymbolRegistry::get

    source
    fn SymbolRegistry::get(self : SymbolRegistry, id : String) -> Symbol?

    SymbolRegistry::new

    source

    TextAnchor

    source
    pub(all) enum TextAnchor {
      Start
      Middle
      End
    }

    Text anchor (horizontal alignment)

    TextBlock

    source
    pub(all) struct TextBlock {
      spans : Array[TextSpan]
      x : Double
      y : Double
      style : TextStyle
      inline_size : Double?
      text_overflow : TextOverflow
    }

    Multi-line text block (SVG 2.0 extended)

    TextBlock::add_span

    source
    fn TextBlock::add_span(self : TextBlock, span : TextSpan) -> Unit

    TextBlock::get_anchor_x

    source
    fn TextBlock::get_anchor_x(self : TextBlock) -> Double

    Get adjusted x position based on text-anchor

    TextBlock::get_baseline_y

    source
    fn TextBlock::get_baseline_y(self : TextBlock) -> Double

    Get adjusted y position based on dominant-baseline

    TextBlock::get_height

    source
    fn TextBlock::get_height(self : TextBlock) -> Double

    Get text height

    TextBlock::get_line_count

    source
    fn TextBlock::get_line_count(self : TextBlock) -> Int

    Get the number of lines when text is wrapped

    TextBlock::get_total_height

    source
    fn TextBlock::get_total_height(self : TextBlock) -> Double

    Get total height including all wrapped lines

    TextBlock::get_width

    source
    fn TextBlock::get_width(self : TextBlock) -> Double

    Calculate text width (simplified - assumes monospace)

    TextBlock::is_vertical

    source
    fn TextBlock::is_vertical(self : TextBlock) -> Bool

    Check if text is vertical (for writing-mode)

    TextBlock::new

    source
    fn TextBlock::new(x : Double, y : Double, text : String) -> TextBlock

    TextBlock::with_style

    source
    fn TextBlock::with_style(x : Double, y : Double, text : String, style : TextStyle) -> TextBlock

    TextBlock::with_wrap

    source
    fn TextBlock::with_wrap(x : Double, y : Double, text : String, inline_size : Double) -> TextBlock

    Create a text block with wrapping

    TextBlock::wrap_text

    source
    fn TextBlock::wrap_text(self : TextBlock) -> Array[String]

    Wrap text to fit within inline_size, returns lines

    TextDecoration

    source
    pub(all) enum TextDecoration {
      NoDecoration
      Underline
      Overline
      LineThrough
    } derive(Eq, 
    Debug    )

    Text decoration

    TextDecorationFull

    source
    pub(all) struct TextDecorationFull {
      line : TextDecoration
      style : TextDecorationStyle
      color : Color?
      thickness : Double?
    }

    Extended text decoration (SVG 2.0)

    TextDecorationFull::default

    source

    TextDecorationStyle

    source
    pub(all) enum TextDecorationStyle {
      Solid
      Double
      Dotted
      Dashed
      Wavy
    } derive(Eq, 
    Debug    )

    Text decoration style (SVG 2.0)

    TextOrientation

    source
    pub(all) enum TextOrientation {
      Mixed
      Upright
      Sideways
    } derive(Eq, 
    Debug    )

    Text orientation for vertical writing (SVG 2.0)

    TextOverflow

    source
    pub(all) enum TextOverflow {
      Clip
      Ellipsis
      Custom(String)
    } derive(Eq, 
    Debug    )

    Text overflow handling (SVG 2.0)

    TextSpan

    source
    pub(all) struct TextSpan {
      text : String
      x : Double?
      y : Double?
      dx : Double
      dy : Double
      style : TextStyle?
    }

    Text span (styled portion of text)

    TextSpan::new

    source
    fn TextSpan::new(text : String) -> TextSpan

    TextSpan::with_offset

    source
    fn TextSpan::with_offset(text : String, dx : Double, dy : Double) -> TextSpan

    TextStyle

    source
    pub(all) struct TextStyle {
      font_family : String
      font_size : Double
      font_weight : FontWeight
      font_style : FontStyle
      text_anchor : TextAnchor
      dominant_baseline : DominantBaseline
      text_decoration : TextDecoration
      letter_spacing : Double
      word_spacing : Double
      line_height : Double
      writing_mode : WritingMode
      text_orientation : TextOrientation
      white_space : WhiteSpace
      paint_order : PaintOrder
    }

    Complete text style (SVG 2.0 extended)

    TextStyle::default

    source
    fn TextStyle::default() -> TextStyle

    Transform

    source
    pub(all) struct Transform {
      a : Double
      b : Double
      c : Double
      d : Double
      e : Double
      f : Double
    }

    2D affine transformation matrix | a c e | | b d f | | 0 0 1 |

    Transform::apply

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

    Apply transform to a point

    Transform::apply_bbox

    source
    fn Transform::apply_bbox(self : Transform, bbox : BoundingBox) -> BoundingBox

    Transform a bounding box (returns axis-aligned bounding box of transformed corners)

    Transform::apply_point

    source
    fn Transform::apply_point(self : Transform, point : (Double, Double)) -> (Double, Double)

    Apply transform to a point (struct version)

    Transform::determinant

    source
    fn Transform::determinant(self : Transform) -> Double

    Compute the determinant of the transform

    Transform::get_rotation

    source
    fn Transform::get_rotation(self : Transform) -> Double

    Get the rotation angle in radians (approximate, assumes uniform scale)

    Transform::get_scale

    source
    fn Transform::get_scale(self : Transform) -> (Double, Double)

    Get the scale factors (approximate, assumes no rotation)

    Transform::get_translate

    source
    fn Transform::get_translate(self : Transform) -> (Double, Double)

    Get the translation component

    Transform::identity

    source
    fn Transform::identity() -> Transform

    Identity transform (no transformation)

    Transform::inverse

    source
    fn Transform::inverse(self : Transform) -> Transform

    Compute the inverse transform Returns identity if not invertible

    Transform::is_identity

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

    Check if this is an identity transform (optimization)

    Transform::is_invertible

    source
    fn Transform::is_invertible(self : Transform) -> Bool

    Check if the transform is invertible

    Transform::matrix

    source
    fn Transform::matrix(a : Double, b : Double, c : Double, d : Double, e : Double, f : Double) -> Transform

    Create a transform from a full matrix specification

    Transform::multiply

    source
    fn Transform::multiply(self : Transform, other : Transform) -> Transform

    Multiply two transforms (self * other) Result: first apply other, then apply self

    Transform::rotate

    source
    fn Transform::rotate(angle : Double) -> Transform

    Create a rotation transform (angle in radians)

    Transform::rotate_around

    source
    fn Transform::rotate_around(angle : Double, cx : Double, cy : Double) -> Transform

    Create a rotation transform around a point (angle in radians)

    Transform::scale

    source
    fn Transform::scale(sx : Double, sy : Double) -> Transform

    Create a scaling transform

    Transform::scale_uniform

    source
    fn Transform::scale_uniform(s : Double) -> Transform

    Create a uniform scaling transform

    Transform::skew_x

    source
    fn Transform::skew_x(angle : Double) -> Transform

    Create a skewX transform (angle in radians)

    Transform::skew_y

    source
    fn Transform::skew_y(angle : Double) -> Transform

    Create a skewY transform (angle in radians)

    Transform::translate

    source
    fn Transform::translate(tx : Double, ty : Double) -> Transform

    Create a translation transform

    Tween

    source
    pub(all) struct Tween {
      target_id : String
      property : AnimProperty
      start_value : AnimProperty
      duration : Double
      elapsed : Double
      easing : Easing
      started : Bool
      completed : Bool
    }

    A single tween animation

    Tween::is_complete

    source
    fn Tween::is_complete(self : Tween) -> Bool

    Check if the tween is complete

    Tween::new

    source
    fn Tween::new(target_id : String, property : AnimProperty, duration : Double, easing : Easing) -> Tween

    Create a new tween

    Tween::update

    source
    fn Tween::update(self : Tween, dt : Double, node : SVGNode) -> Bool

    Update the tween with delta time Returns true if still running, false if complete

    UseElement

    source
    pub(all) struct UseElement {
      href : String
      x : Double
      y : Double
      width : Double?
      height : Double?
      transform : Transform
    }

    Use element (instance of a symbol)

    UseElement::get_id

    source
    fn UseElement::get_id(self : UseElement) -> String

    Get the href ID (strips leading #)

    UseElement::instantiate

    source
    fn UseElement::instantiate(self : UseElement, registry : SymbolRegistry) -> SVGNode?

    Instantiate a use element with the symbol registry

    UseElement::new

    source
    fn UseElement::new(href : String, x : Double, y : Double) -> UseElement

    UseElement::with_size

    source
    fn UseElement::with_size(href : String, x : Double, y : Double, width : Double, height : Double) -> UseElement

    ViewBox

    source
    pub(all) struct ViewBox {
      min_x : Double
      min_y : Double
      width : Double
      height : Double
    }

    ViewBox specification for SVG coordinate system mapping

    ViewBox::get_transform

    source
    fn ViewBox::get_transform(self : ViewBox, viewport_width : Double, viewport_height : Double, preserve_aspect_ratio : PreserveAspectRatio) -> Transform

    Calculate the transform matrix to map viewBox coordinates to viewport viewport_width/height: the actual pixel dimensions of the SVG element

    WhiteSpace

    source
    pub(all) enum WhiteSpace {
      Normal
      Pre
      NoWrap
      PreWrap
      PreLine
      BreakSpaces
    } derive(Eq, 
    Debug    )

    White space handling (SVG 2.0)
    impl Show for WhiteSpace

    WritingMode

    source
    pub(all) enum WritingMode {
      HorizontalTB
      VerticalRL
      VerticalLR
    } derive(Eq, 
    Debug    )

    Writing mode (SVG 2.0)
    impl Show for WritingMode

    apply_blur

    source
    fn apply_blur(pixels : Array[Array[Color]], radius : Int) -> Array[Array[Color]]

    Apply blur filter to a region of pixels

    apply_brightness

    source
    fn apply_brightness(color : Color, factor : Double) -> Color

    Apply brightness filter to a color

    apply_color_matrix

    source
    fn apply_color_matrix(color : Color, matrix : FixedArray[Double]) -> Color

    Apply color matrix filter (feColorMatrix) Matrix is 5x4 (20 values) in row-major order: [R'] = [a00 a01 a02 a03 a04] [R] [G'] = [a10 a11 a12 a13 a14] [G] [B'] = [a20 a21 a22 a23 a24] [B] [A'] = [a30 a31 a32 a33 a34] [A] [1]

    apply_contrast

    source
    fn apply_contrast(color : Color, factor : Double) -> Color

    Apply contrast filter to a color

    apply_drop_shadow

    source
    fn apply_drop_shadow(image : Image, offset_x : Int, offset_y : Int, blur_radius : Int, shadow_color : Color) -> Image

    Apply drop shadow to an image and return new image with shadow

    apply_filter

    source
    fn apply_filter(image : Image, filter : Filter) -> Image

    Apply a filter to an image (returns new image)

    apply_grayscale

    source
    fn apply_grayscale(color : Color, amount : Double) -> Color

    Apply grayscale filter to a color

    apply_hue_rotate

    source
    fn apply_hue_rotate(color : Color, angle_degrees : Double) -> Color

    Apply hue rotation to a color

    apply_invert

    source
    fn apply_invert(color : Color, amount : Double) -> Color

    Apply invert filter to a color

    apply_mask_to_image

    source
    fn apply_mask_to_image(image : Image, mask_buffer : Image, mask_type : MaskType) -> Image

    Apply mask to an image using luminance or alpha

    apply_saturate

    source
    fn apply_saturate(color : Color, factor : Double) -> Color

    Apply saturate filter to a color

    apply_sepia

    source
    fn apply_sepia(color : Color, amount : Double) -> Color

    Apply sepia filter to a color

    apply_text_overflow

    source
    fn apply_text_overflow(line : String, max_width : Double, char_width : Double, overflow : TextOverflow) -> String

    Apply text-overflow to a line

    blend_images

    source
    fn blend_images(backdrop : Image, source : Image, mode : BlendMode) -> Image

    Blend two images using the specified blend mode

    blend_with_mode

    source
    fn blend_with_mode(backdrop : Color, source : Color, mode : BlendMode) -> Color

    Blend two colors using the specified blend mode

    blit

    source
    fn blit(dest : Image, src : Image, dest_x : Int, dest_y : Int) -> Unit

    Blit (copy) source image onto destination at position

    blit_scaled

    source
    fn blit_scaled(dest : Image, src : Image, dest_x : Int, dest_y : Int, dest_w : Int, dest_h : Int) -> Unit

    Blit with scaling

    blit_sprite

    source
    fn blit_sprite(dest : Image, sprite : Sprite, dest_x : Int, dest_y : Int) -> Unit

    Blit sprite onto image

    circle

    source
    fn circle(id : String, cx : Double, cy : Double, r : Double) -> SVGNode

    Helper: Create a circle node

    collide_circle_circle

    source
    fn collide_circle_circle(cx1 : Double, cy1 : Double, r1 : Double, cx2 : Double, cy2 : Double, r2 : Double) -> Bool

    Check collision between two circles

    collide_circle_rect

    source
    fn collide_circle_rect(cx : Double, cy : Double, r : Double, rx : Double, ry : Double, rw : Double, rh : Double) -> Bool

    Check collision between circle and rectangle

    collide_rect_rect

    source
    fn collide_rect_rect(x1 : Double, y1 : Double, w1 : Double, h1 : Double, x2 : Double, y2 : Double, w2 : Double, h2 : Double) -> Bool

    Check collision between two axis-aligned rectangles

    collide_shapes

    source
    fn collide_shapes(shape1 : Shape, shape2 : Shape) -> Bool

    Check collision between two shapes

    compute_alpha_mask

    source
    fn compute_alpha_mask(color : Color) -> Double

    Compute mask value using alpha channel

    compute_luminance

    source
    fn compute_luminance(color : Color) -> Double

    Compute mask value (0.0-1.0) at a point using luminance

    degrees_to_radians

    source
    fn degrees_to_radians(degrees : Double) -> Double

    Convert degrees to radians

    group

    source
    fn group(id : String, children : Array[SVGNode]) -> SVGNode

    Helper: Create a group node

    hit_test_shape

    source
    fn hit_test_shape(px : Double, py : Double, shape : Shape) -> Bool

    Hit test a shape (without transform)

    hue_rotate_matrix

    source
    fn hue_rotate_matrix(angle_degrees : Double) -> FixedArray[Double]

    Create hue-rotate color matrix

    identity_matrix

    source
    fn identity_matrix() -> FixedArray[Double]

    Create identity color matrix

    line

    source
    fn line(id : String, x1 : Double, y1 : Double, x2 : Double, y2 : Double) -> SVGNode

    Helper: Create a line node

    luminance_to_alpha_matrix

    source
    fn luminance_to_alpha_matrix() -> FixedArray[Double]

    Create luminance-to-alpha color matrix

    lut_color_at

    source
    fn lut_color_at(lut : Array[Color], t : Double) -> Color

    Get color from LUT (fast path)

    parse_path

    source
    fn parse_path(data : String) -> Array[PathCommand]

    Parse a path data string into an array of path commands

    parse_svg

    source
    fn parse_svg(svg_str : String) -> SVGNode?

    Parse SVG markup string into SVGNode

    parse_svg_document

    source
    fn parse_svg_document(svg_str : String) -> SVGDocument?

    Parse SVG markup string into SVGDocument with resources

    parse_transform

    source
    fn parse_transform(value : String) -> Transform

    path

    source
    fn path(id : String, d : String) -> SVGNode

    Helper: Create a path node from path data string

    path_bbox

    source
    fn path_bbox(commands : Array[PathCommand]) -> BoundingBox

    Compute bounding box of path commands

    path_to_polylines

    source
    fn path_to_polylines(commands : Array[PathCommand], flatness : Double) -> Array[Array[(Double, Double)]]

    Convert path commands to an array of polylines (for rendering) Returns array of point arrays, each representing a subpath

    process_white_space

    source
    fn process_white_space(text : String, mode : WhiteSpace) -> String

    Process white-space according to mode

    radians_to_degrees

    source
    fn radians_to_degrees(radians : Double) -> Double

    Convert radians to degrees

    raster_circle_fill

    source
    fn raster_circle_fill(cx : Int, cy : Int, r : Int, color : Color, setter : PixelSetter) -> Unit

    Fill circle using scanlines

    raster_circle_radial_gradient

    source
    fn raster_circle_radial_gradient(cx : Int, cy : Int, r : Int, grad : RadialGradient, opacity : Double, setter : PixelSetter) -> Unit

    Draw filled circle with radial gradient

    raster_circle_stroke

    source
    fn raster_circle_stroke(cx : Int, cy : Int, r : Int, color : Color, setter : PixelSetter) -> Unit

    Midpoint circle algorithm - draw circle outline

    raster_ellipse_fill

    source
    fn raster_ellipse_fill(cx : Int, cy : Int, rx : Int, ry : Int, color : Color, setter : PixelSetter) -> Unit

    Fill ellipse using scanlines

    raster_ellipse_radial_gradient

    source
    fn raster_ellipse_radial_gradient(cx : Int, cy : Int, rx : Int, ry : Int, grad : RadialGradient, opacity : Double, setter : PixelSetter) -> Unit

    Draw filled ellipse with radial gradient

    raster_ellipse_stroke

    source
    fn raster_ellipse_stroke(cx : Int, cy : Int, rx : Int, ry : Int, color : Color, setter : PixelSetter) -> Unit

    Midpoint ellipse algorithm - draw ellipse outline

    raster_line

    source
    fn raster_line(x0 : Int, y0 : Int, x1 : Int, y1 : Int, color : Color, setter : PixelSetter) -> Unit

    Bresenham's line algorithm - integer-only, efficient line drawing

    raster_line_dashed

    source
    fn raster_line_dashed(x0 : Int, y0 : Int, x1 : Int, y1 : Int, color : Color, dasharray : Array[Double], dashoffset : Double, setter : PixelSetter) -> Unit

    Bresenham's line with dash pattern support

    raster_path

    source
    fn raster_path(commands : Array[PathCommand], fill_color : Color?, stroke_color : Color?, flatness : Double, setter : PixelSetter) -> Unit

    Rasterize path commands

    raster_polygon_fill

    source
    fn raster_polygon_fill(points : Array[(Int, Int)], color : Color, setter : PixelSetter) -> Unit

    Polygon fill using scanline algorithm with edge table

    raster_polygon_fill_rule

    source
    fn raster_polygon_fill_rule(points : Array[(Int, Int)], color : Color, rule : FillRule, setter : PixelSetter) -> Unit

    Polygon fill with specified fill rule

    raster_polygon_stroke

    source
    fn raster_polygon_stroke(points : Array[(Int, Int)], color : Color, setter : PixelSetter) -> Unit

    Draw polygon outline

    raster_polygons_fill_rule

    source
    fn raster_polygons_fill_rule(polygons : Array[Array[(Int, Int)]], color : Color, rule : FillRule, setter : PixelSetter) -> Unit

    Fill multiple polygons (subpaths) with specified fill rule

    raster_polyline

    source
    fn raster_polyline(points : Array[(Int, Int)], color : Color, setter : PixelSetter) -> Unit

    Draw polyline (open polygon)

    raster_polyline_dashed

    source
    fn raster_polyline_dashed(points : Array[(Int, Int)], color : Color, dasharray : Array[Double], dashoffset : Double, setter : PixelSetter) -> Unit

    Draw polyline with dash pattern

    raster_rect_fill

    source
    fn raster_rect_fill(x : Int, y : Int, w : Int, h : Int, color : Color, setter : PixelSetter) -> Unit

    Fill rectangle

    raster_rect_gradient

    source
    fn raster_rect_gradient(x : Int, y : Int, w : Int, h : Int, grad : LinearGradient, opacity : Double, setter : PixelSetter) -> Unit

    Draw filled rectangle with linear gradient

    raster_rect_radial_gradient

    source
    fn raster_rect_radial_gradient(x : Int, y : Int, w : Int, h : Int, grad : RadialGradient, opacity : Double, setter : PixelSetter) -> Unit

    Draw filled rectangle with radial gradient

    raster_rect_stroke

    source
    fn raster_rect_stroke(x : Int, y : Int, w : Int, h : Int, color : Color, setter : PixelSetter) -> Unit

    Draw rectangle outline (stroke only)

    raster_rect_stroke_thick

    source
    fn raster_rect_stroke_thick(x : Int, y : Int, w : Int, h : Int, stroke_w : Int, color : Color, setter : PixelSetter) -> Unit

    raster_rounded_rect_fill

    source
    fn raster_rounded_rect_fill(x : Int, y : Int, w : Int, h : Int, rx : Int, ry : Int, color : Color, setter : PixelSetter) -> Unit

    raster_rounded_rect_stroke

    source
    fn raster_rounded_rect_stroke(x : Int, y : Int, w : Int, h : Int, rx : Int, ry : Int, color : Color, setter : PixelSetter) -> Unit

    Draw rounded rectangle outline

    raster_rounded_rect_stroke_thick

    source
    fn raster_rounded_rect_stroke_thick(x : Int, y : Int, w : Int, h : Int, rx : Int, ry : Int, stroke_w : Int, color : Color, setter : PixelSetter) -> Unit

    raster_text

    source
    fn raster_text(x : Int, y : Int, text : String, font_size : Int, color : Color, setter : PixelSetter) -> Unit

    Render text using bitmap font

    raster_thick_line

    source
    fn raster_thick_line(x0 : Int, y0 : Int, x1 : Int, y1 : Int, width : Int, color : Color, setter : PixelSetter) -> Unit

    Draw a thick line (stroke width > 1)

    rect

    source
    fn rect(id : String, x : Double, y : Double, width : Double, height : Double) -> SVGNode

    Helper: Create a rectangle node

    render_path_commands_to_image

    source
    fn render_path_commands_to_image(commands : Array[PathCommand], width : Int, height : Int, fill_color : Color, transform? : Array[Double]) -> Image

    Render PathCommand array directly to an Image (no SVG string parsing). This is much faster than render_svg_to_image for programmatic paths (e.g., font glyph outlines) because it skips SVG serialization and parsing.

    transform is a 6-element affine transform [a, b, c, d, e, f] or empty for identity.

    render_svg_document_to_image

    source
    fn render_svg_document_to_image(doc : SVGDocument, width : Int, height : Int) -> Image

    Render an SVGDocument into an Image.

    render_svg_node_to_image

    source
    fn render_svg_node_to_image(node : SVGNode, width : Int, height : Int) -> Image

    Render a raw SVGNode tree into an Image.

    render_svg_scene_to_image

    source
    fn render_svg_scene_to_image(scene : Scene, width : Int, height : Int) -> Image

    Render a Scene into an Image.

    render_svg_to_image

    source
    fn render_svg_to_image(svg_str : String, width : Int, height : Int) -> Image?

    Parse and render an SVG markup string into an Image.

    saturate_matrix

    source
    fn saturate_matrix(factor : Double) -> FixedArray[Double]

    Create saturate color matrix

    text

    source
    fn text(id : String, x : Double, y : Double, content : String, font_size : Double) -> SVGNode

    Helper: Create a text node

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io