ranma 0.1.0

data/ext/ranma/src/painter.rs

@@ -0,0 +1,1082 @@
+use std::borrow::Cow;
+use std::cell::RefCell;
+use std::collections::HashMap;
+use magnus::{function, gc, method, prelude::*, Error, RHash, Ruby, TryConvert, Value};
+use vello::kurbo::{Affine, Arc, BezPath, Circle, Line, PathEl, Rect, RoundedRect, Shape};
+use vello::peniko::{self, Brush, Color, Fill};
+use vello::Scene;
+
+use crate::surface::RbGpuSurface;
+
+// --- Thread-local shared resources ---
+
+thread_local! {
+    static FONT_CONTEXT: RefCell<parley::FontContext> = RefCell::new(parley::FontContext::default());
+    static LAYOUT_CONTEXT: RefCell<parley::LayoutContext<[u8; 4]>> = RefCell::new(parley::LayoutContext::new());
+    static IMAGE_CACHE: RefCell<HashMap<String, CachedImage>> = RefCell::new(HashMap::new());
+}
+
+struct CachedImage {
+    data: peniko::ImageData,
+}
+
+// --- Color parsing ---
+
+fn parse_color(s: &str) -> Color {
+    let s = s.strip_prefix('#').unwrap_or(s);
+    match s.len() {
+        3 => {
+            let r = u8::from_str_radix(&s[0..1], 16).unwrap_or(0);
+            let g = u8::from_str_radix(&s[1..2], 16).unwrap_or(0);
+            let b = u8::from_str_radix(&s[2..3], 16).unwrap_or(0);
+            Color::from_rgba8(r * 17, g * 17, b * 17, 255)
+        }
+        6 => {
+            let r = u8::from_str_radix(&s[0..2], 16).unwrap_or(0);
+            let g = u8::from_str_radix(&s[2..4], 16).unwrap_or(0);
+            let b = u8::from_str_radix(&s[4..6], 16).unwrap_or(0);
+            Color::from_rgba8(r, g, b, 255)
+        }
+        8 => {
+            let r = u8::from_str_radix(&s[0..2], 16).unwrap_or(0);
+            let g = u8::from_str_radix(&s[2..4], 16).unwrap_or(0);
+            let b = u8::from_str_radix(&s[4..6], 16).unwrap_or(0);
+            let a = u8::from_str_radix(&s[6..8], 16).unwrap_or(255);
+            Color::from_rgba8(r, g, b, a)
+        }
+        _ => Color::from_rgba8(0, 0, 0, 255),
+    }
+}
+
+fn color_to_rgba8(c: &Color) -> [u8; 4] {
+    let rgba = c.to_rgba8();
+    [rgba.r, rgba.g, rgba.b, rgba.a]
+}
+
+// --- State structs ---
+
+#[derive(Clone)]
+struct ShadowState {
+    color: Color,
+    offset_x: f64,
+    offset_y: f64,
+    blur_radius: f64,
+}
+
+#[derive(Clone)]
+struct PainterState {
+    transform: Affine,
+    fill_color: Color,
+    stroke_color: Color,
+    stroke_width: f64,
+    font_family: Option<String>,
+    font_size: f32,
+    border_radius: f64,
+    shadow: Option<ShadowState>,
+    clip_depth: usize,
+}
+
+struct PainterInner {
+    scene: Scene,
+    transform: Affine,
+    fill_color: Color,
+    stroke_color: Color,
+    stroke_width: f64,
+    font_family: Option<String>,
+    font_size: f32,
+    border_radius: f64,
+    shadow: Option<ShadowState>,
+    state_stack: Vec<PainterState>,
+    clip_depth: usize,
+    is_sub_painter: bool,
+    path: Option<BezPath>,
+}
+
+impl PainterInner {
+    fn default_fill_color() -> Color {
+        Color::from_rgba8(0, 0, 0, 255)
+    }
+
+    fn default_stroke_color() -> Color {
+        Color::from_rgba8(0, 0, 0, 255)
+    }
+
+    fn draw_shadow_for_rect(&mut self, rect: Rect) {
+        if let Some(ref shadow) = self.shadow {
+            let shadow_rect = Rect::new(
+                rect.x0 + shadow.offset_x,
+                rect.y0 + shadow.offset_y,
+                rect.x1 + shadow.offset_x,
+                rect.y1 + shadow.offset_y,
+            );
+            let transform = self.transform;
+            let border_radius = self.border_radius;
+            self.scene.draw_blurred_rounded_rect(
+                transform,
+                shadow_rect,
+                shadow.color,
+                border_radius,
+                shadow.blur_radius,
+            );
+        }
+    }
+}
+
+#[magnus::wrap(class = "Ranma::Painter", free_immediately, size)]
+pub struct RbPainter {
+    surface: Value,
+    inner: RefCell<PainterInner>,
+}
+
+unsafe impl Send for RbPainter {}
+
+impl RbPainter {
+    fn new(surface: Value) -> Result<Self, Error> {
+        gc::register_mark_object(surface);
+        Ok(RbPainter {
+            surface,
+            inner: RefCell::new(PainterInner {
+                scene: Scene::new(),
+                transform: Affine::IDENTITY,
+                fill_color: PainterInner::default_fill_color(),
+                stroke_color: PainterInner::default_stroke_color(),
+                stroke_width: 1.0,
+                font_family: None,
+                font_size: 16.0,
+                border_radius: 0.0,
+                shadow: None,
+                state_stack: Vec::new(),
+                clip_depth: 0,
+                is_sub_painter: false,
+                path: None,
+            }),
+        })
+    }
+
+    // --- Drawing methods ---
+
+    fn clear_all(&self, color: Option<String>) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        inner.scene.reset();
+        if let Some(c) = color {
+            let color = parse_color(&c);
+            let rect = Rect::new(0.0, 0.0, 1e6, 1e6);
+            inner
+                .scene
+                .fill(Fill::NonZero, Affine::IDENTITY, color, None, &rect);
+        }
+        Ok(())
+    }
+
+    fn fill_rect(&self, x: f64, y: f64, w: f64, h: f64) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        let rect = Rect::new(x, y, x + w, y + h);
+        inner.draw_shadow_for_rect(rect);
+        let transform = inner.transform;
+        let fill_color = inner.fill_color;
+        let border_radius = inner.border_radius;
+        if border_radius > 0.0 {
+            let rrect = RoundedRect::from_rect(rect, border_radius);
+            inner
+                .scene
+                .fill(Fill::NonZero, transform, fill_color, None, &rrect);
+        } else {
+            inner
+                .scene
+                .fill(Fill::NonZero, transform, fill_color, None, &rect);
+        }
+        Ok(())
+    }
+
+    fn stroke_rect(&self, x: f64, y: f64, w: f64, h: f64) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        let rect = Rect::new(x, y, x + w, y + h);
+        let stroke = vello::kurbo::Stroke::new(inner.stroke_width);
+        let transform = inner.transform;
+        let stroke_color = inner.stroke_color;
+        let border_radius = inner.border_radius;
+        if border_radius > 0.0 {
+            let rrect = RoundedRect::from_rect(rect, border_radius);
+            inner
+                .scene
+                .stroke(&stroke, transform, stroke_color, None, &rrect);
+        } else {
+            inner
+                .scene
+                .stroke(&stroke, transform, stroke_color, None, &rect);
+        }
+        Ok(())
+    }
+
+    fn fill_circle(&self, cx: f64, cy: f64, r: f64) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        let circle = Circle::new((cx, cy), r);
+        let transform = inner.transform;
+        let fill_color = inner.fill_color;
+        inner
+            .scene
+            .fill(Fill::NonZero, transform, fill_color, None, &circle);
+        Ok(())
+    }
+
+    fn stroke_circle(&self, cx: f64, cy: f64, r: f64) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        let circle = Circle::new((cx, cy), r);
+        let stroke = vello::kurbo::Stroke::new(inner.stroke_width);
+        let transform = inner.transform;
+        let stroke_color = inner.stroke_color;
+        inner
+            .scene
+            .stroke(&stroke, transform, stroke_color, None, &circle);
+        Ok(())
+    }
+
+    fn fill_text(&self, text: String, x: f64, y: f64, max_width: Option<f32>) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        let fill_color = inner.fill_color;
+        let fill_rgba = color_to_rgba8(&fill_color);
+        let font_size = inner.font_size;
+        let font_family = inner.font_family.clone();
+        let base_transform = inner.transform;
+
+        FONT_CONTEXT.with(|fc| {
+            LAYOUT_CONTEXT.with(|lc| {
+                let mut fc = fc.borrow_mut();
+                let mut lc = lc.borrow_mut();
+
+                let mut builder = lc.ranged_builder(&mut fc, &text, 1.0, false);
+                builder.push_default(parley::StyleProperty::FontSize(font_size));
+                builder.push_default(parley::StyleProperty::Brush(fill_rgba));
+                if let Some(ref family) = font_family {
+                    builder.push_default(parley::StyleProperty::FontStack(
+                        parley::FontStack::Source(Cow::Borrowed(family.as_str())),
+                    ));
+                } else {
+                    builder.push_default(parley::GenericFamily::SystemUi);
+                }
+
+                let mut layout = builder.build(&text);
+                let max_w = max_width.unwrap_or(f32::MAX);
+                layout.break_all_lines(Some(max_w));
+                layout.align(Some(max_w), parley::Alignment::Start, Default::default());
+
+                let transform = base_transform.then_translate((x, y).into());
+                for line in layout.lines() {
+                    for item in line.items() {
+                        let parley::PositionedLayoutItem::GlyphRun(glyph_run) = item else {
+                            continue;
+                        };
+                        let run = glyph_run.run();
+                        let font = run.font().clone();
+                        let glyph_xform = run
+                            .synthesis()
+                            .skew()
+                            .map(|angle| Affine::skew(angle.tan() as f64, 0.0));
+                        let coords: Vec<_> = run
+                            .normalized_coords()
+                            .iter()
+                            .map(|c| *c as vello::NormalizedCoord)
+                            .collect();
+
+                        inner
+                            .scene
+                            .draw_glyphs(&font)
+                            .font_size(run.font_size())
+                            .transform(transform)
+                            .glyph_transform(glyph_xform)
+                            .normalized_coords(&coords)
+                            .brush(&fill_color)
+                            .draw(
+                                Fill::NonZero,
+                                glyph_run.positioned_glyphs().map(|g| vello::Glyph {
+                                    id: g.id as u32,
+                                    x: g.x,
+                                    y: g.y,
+                                }),
+                            );
+                    }
+                }
+            });
+        });
+        Ok(())
+    }
+
+    fn measure_text(&self, text: String) -> f32 {
+        if text.is_empty() {
+            return 0.0;
+        }
+
+        let inner = self.inner.borrow();
+        let font_size = inner.font_size;
+        let font_family = inner.font_family.clone();
+
+        FONT_CONTEXT.with(|fc| {
+            LAYOUT_CONTEXT.with(|lc| {
+                let mut fc = fc.borrow_mut();
+                let mut lc = lc.borrow_mut();
+
+                let mut builder = lc.ranged_builder(&mut fc, &text, 1.0, false);
+                builder.push_default(parley::StyleProperty::FontSize(font_size));
+                if let Some(ref family) = font_family {
+                    builder.push_default(parley::StyleProperty::FontStack(
+                        parley::FontStack::Source(Cow::Borrowed(family.as_str())),
+                    ));
+                } else {
+                    builder.push_default(parley::GenericFamily::SystemUi);
+                }
+
+                let mut layout = builder.build(&text);
+                layout.break_all_lines(None);
+                layout.full_width()
+            })
+        })
+    }
+
+    fn get_font_metrics(&self) -> RbPainterFontMetrics {
+        let inner = self.inner.borrow();
+        let font_size = inner.font_size;
+        let font_family = inner.font_family.clone();
+
+        FONT_CONTEXT.with(|fc| {
+            LAYOUT_CONTEXT.with(|lc| {
+                let mut fc = fc.borrow_mut();
+                let mut lc = lc.borrow_mut();
+
+                let sample = " ";
+                let mut builder = lc.ranged_builder(&mut fc, sample, 1.0, false);
+                builder.push_default(parley::StyleProperty::FontSize(font_size));
+                if let Some(ref family) = font_family {
+                    builder.push_default(parley::StyleProperty::FontStack(
+                        parley::FontStack::Source(Cow::Borrowed(family.as_str())),
+                    ));
+                } else {
+                    builder.push_default(parley::GenericFamily::SystemUi);
+                }
+
+                let mut layout = builder.build(sample);
+                layout.break_all_lines(None);
+
+                let result = if let Some(line) = layout.lines().next() {
+                    let metrics = line.metrics();
+                    RbPainterFontMetrics {
+                        ascent: metrics.ascent,
+                        descent: metrics.descent,
+                        leading: metrics.leading,
+                        height: metrics.ascent + metrics.descent + metrics.leading,
+                    }
+                } else {
+                    RbPainterFontMetrics {
+                        ascent: font_size,
+                        descent: 0.0,
+                        leading: 0.0,
+                        height: font_size,
+                    }
+                };
+                result
+            })
+        })
+    }
+
+    fn draw_image(&self, path: String, x: f64, y: f64, w: f64, h: f64) -> Result<(), Error> {
+        let img = load_image(&path, true)?;
+
+        let img_w = img.width as f64;
+        let img_h = img.height as f64;
+
+        let scale_x = w / img_w;
+        let scale_y = h / img_h;
+
+        let mut inner = self.inner.borrow_mut();
+        let base_transform = inner.transform;
+        let transform = base_transform
+            .then_translate((x, y).into())
+            .then_scale_non_uniform(scale_x, scale_y);
+
+        let rect = Rect::new(0.0, 0.0, img_w, img_h);
+        let brush = peniko::ImageBrush::new(img);
+
+        inner
+            .scene
+            .fill(Fill::NonZero, transform, &Brush::Image(brush), None, &rect);
+
+        Ok(())
+    }
+
+    fn measure_image(&self, path: String) -> Result<(i32, i32), Error> {
+        let img = load_image(&path, true)?;
+        Ok((img.width as i32, img.height as i32))
+    }
+
+    fn draw_caret(&self, x: f64, y: f64, height: f64) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        let rect = Rect::new(x, y, x + 1.0, y + height);
+        let transform = inner.transform;
+        let fill_color = inner.fill_color;
+        inner
+            .scene
+            .fill(Fill::NonZero, transform, fill_color, None, &rect);
+        Ok(())
+    }
+
+    fn draw_line(&self, x1: f64, y1: f64, x2: f64, y2: f64) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        let line = Line::new((x1, y1), (x2, y2));
+        let stroke = vello::kurbo::Stroke::new(inner.stroke_width);
+        let transform = inner.transform;
+        let stroke_color = inner.stroke_color;
+        inner.scene.stroke(&stroke, transform, stroke_color, None, &line);
+        Ok(())
+    }
+
+    fn fill_arc(&self, cx: f64, cy: f64, r: f64, start_deg: f64, sweep_deg: f64) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        let start_rad = start_deg.to_radians();
+        let sweep_rad = sweep_deg.to_radians();
+        // Build a pie-slice path: center → arc_start (line) → arc curve → close
+        let mut path = BezPath::new();
+        path.move_to((cx, cy));
+        let arc = Arc::new((cx, cy), (r, r), start_rad, sweep_rad, 0.0);
+        let mut elems = arc.path_elements(0.1).peekable();
+        if elems.peek().is_some() {
+            // First element is MoveTo(arc_start); replace with LineTo to connect from center
+            if let Some(PathEl::MoveTo(p)) = elems.next() {
+                path.line_to(p);
+            }
+            for elem in elems {
+                path.push(elem);
+            }
+        }
+        path.close_path();
+        let transform = inner.transform;
+        let fill_color = inner.fill_color;
+        inner.scene.fill(Fill::NonZero, transform, fill_color, None, &path);
+        Ok(())
+    }
+
+    fn stroke_arc(&self, cx: f64, cy: f64, r: f64, start_deg: f64, sweep_deg: f64) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        let start_rad = start_deg.to_radians();
+        let sweep_rad = sweep_deg.to_radians();
+        let arc = Arc::new((cx, cy), (r, r), start_rad, sweep_rad, 0.0);
+        let mut path = BezPath::new();
+        for elem in arc.path_elements(0.1) {
+            path.push(elem);
+        }
+        let stroke = vello::kurbo::Stroke::new(inner.stroke_width);
+        let transform = inner.transform;
+        let stroke_color = inner.stroke_color;
+        inner.scene.stroke(&stroke, transform, stroke_color, None, &path);
+        Ok(())
+    }
+
+    fn fill_triangle(&self, x1: f64, y1: f64, x2: f64, y2: f64, x3: f64, y3: f64) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        let mut path = BezPath::new();
+        path.move_to((x1, y1));
+        path.line_to((x2, y2));
+        path.line_to((x3, y3));
+        path.close_path();
+        let transform = inner.transform;
+        let fill_color = inner.fill_color;
+        inner.scene.fill(Fill::NonZero, transform, fill_color, None, &path);
+        Ok(())
+    }
+
+    fn begin_path(&self) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        inner.path = Some(BezPath::new());
+        Ok(())
+    }
+
+    fn path_move_to(&self, x: f64, y: f64) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        if let Some(ref mut path) = inner.path {
+            path.move_to((x, y));
+        }
+        Ok(())
+    }
+
+    fn path_line_to(&self, x: f64, y: f64) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        if let Some(ref mut path) = inner.path {
+            path.line_to((x, y));
+        }
+        Ok(())
+    }
+
+    fn fill_path(&self) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        let path_clone = inner.path.clone();
+        if let Some(ref path) = path_clone {
+            let transform = inner.transform;
+            let fill_color = inner.fill_color;
+            inner.scene.fill(Fill::NonZero, transform, fill_color, None, path);
+        }
+        Ok(())
+    }
+
+    fn close_fill_path(&self) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        if let Some(ref mut path) = inner.path {
+            path.close_path();
+        }
+        let path_clone = inner.path.clone();
+        if let Some(ref path) = path_clone {
+            let transform = inner.transform;
+            let fill_color = inner.fill_color;
+            inner.scene.fill(Fill::NonZero, transform, fill_color, None, path);
+        }
+        Ok(())
+    }
+
+    fn measure_text_with_font(&self, text: String, font_family: String, font_size: f64) -> f32 {
+        if text.is_empty() {
+            return 0.0;
+        }
+        let font_size_f32 = font_size as f32;
+        FONT_CONTEXT.with(|fc| {
+            LAYOUT_CONTEXT.with(|lc| {
+                let mut fc = fc.borrow_mut();
+                let mut lc = lc.borrow_mut();
+                let mut builder = lc.ranged_builder(&mut fc, &text, 1.0, false);
+                builder.push_default(parley::StyleProperty::FontSize(font_size_f32));
+                if !font_family.is_empty() && font_family != "default" {
+                    builder.push_default(parley::StyleProperty::FontStack(
+                        parley::FontStack::Source(Cow::Owned(font_family)),
+                    ));
+                } else {
+                    builder.push_default(parley::GenericFamily::SystemUi);
+                }
+                let mut layout = builder.build(&text);
+                layout.break_all_lines(None);
+                layout.full_width()
+            })
+        })
+    }
+
+    fn get_font_metrics_with_font(&self, font_family: String, font_size: f64) -> RbPainterFontMetrics {
+        let font_size_f32 = font_size as f32;
+        FONT_CONTEXT.with(|fc| {
+            LAYOUT_CONTEXT.with(|lc| {
+                let mut fc = fc.borrow_mut();
+                let mut lc = lc.borrow_mut();
+                let sample = " ";
+                let mut builder = lc.ranged_builder(&mut fc, sample, 1.0, false);
+                builder.push_default(parley::StyleProperty::FontSize(font_size_f32));
+                if !font_family.is_empty() && font_family != "default" {
+                    builder.push_default(parley::StyleProperty::FontStack(
+                        parley::FontStack::Source(Cow::Owned(font_family)),
+                    ));
+                } else {
+                    builder.push_default(parley::GenericFamily::SystemUi);
+                }
+                let mut layout = builder.build(sample);
+                layout.break_all_lines(None);
+                let result = if let Some(line) = layout.lines().next() {
+                    let metrics = line.metrics();
+                    RbPainterFontMetrics {
+                        ascent: metrics.ascent,
+                        descent: metrics.descent,
+                        leading: metrics.leading,
+                        height: metrics.ascent + metrics.descent + metrics.leading,
+                    }
+                } else {
+                    RbPainterFontMetrics {
+                        ascent: font_size_f32,
+                        descent: 0.0,
+                        leading: 0.0,
+                        height: font_size_f32,
+                    }
+                };
+                result
+            })
+        })
+    }
+
+    // --- State management ---
+
+    fn save(&self) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        let state = PainterState {
+            transform: inner.transform,
+            fill_color: inner.fill_color,
+            stroke_color: inner.stroke_color,
+            stroke_width: inner.stroke_width,
+            font_family: inner.font_family.clone(),
+            font_size: inner.font_size,
+            border_radius: inner.border_radius,
+            shadow: inner.shadow.clone(),
+            clip_depth: inner.clip_depth,
+        };
+        inner.state_stack.push(state);
+        inner.clip_depth = 0;
+        Ok(())
+    }
+
+    fn restore(&self) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        for _ in 0..inner.clip_depth {
+            inner.scene.pop_layer();
+        }
+
+        if let Some(state) = inner.state_stack.pop() {
+            inner.transform = state.transform;
+            inner.fill_color = state.fill_color;
+            inner.stroke_color = state.stroke_color;
+            inner.stroke_width = state.stroke_width;
+            inner.font_family = state.font_family;
+            inner.font_size = state.font_size;
+            inner.border_radius = state.border_radius;
+            inner.shadow = state.shadow;
+            inner.clip_depth = state.clip_depth;
+        }
+        Ok(())
+    }
+
+    fn translate(&self, x: f64, y: f64) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        inner.transform = inner.transform.then_translate((x, y).into());
+        Ok(())
+    }
+
+    fn scale(&self, sx: f64, sy: f64) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        let t = inner.transform;
+        inner.transform = Affine::scale_non_uniform(sx, sy) * t;
+        Ok(())
+    }
+
+    fn clip(&self, x: f64, y: f64, w: f64, h: f64) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        let rect = Rect::new(x, y, x + w, y + h);
+        let transform = inner.transform;
+        inner
+            .scene
+            .push_clip_layer(Fill::NonZero, transform, &rect);
+        inner.clip_depth += 1;
+        Ok(())
+    }
+
+    fn style(&self, style: &RbPainterStyle) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        if let Some(ref c) = style.fill_color {
+            inner.fill_color = parse_color(c);
+        }
+        if let Some(ref c) = style.stroke_color {
+            inner.stroke_color = parse_color(c);
+        }
+        if style.stroke_width >= 0.0 {
+            inner.stroke_width = style.stroke_width as f64;
+        }
+        if let Some(ref family) = style.font_family {
+            inner.font_family = Some(family.clone());
+        }
+        if style.font_size > 0.0 {
+            inner.font_size = style.font_size;
+        }
+        if style.border_radius >= 0.0 {
+            inner.border_radius = style.border_radius as f64;
+        }
+        if let Some(ref shadow) = style.shadow {
+            inner.shadow = Some(ShadowState {
+                color: parse_color(&shadow.color),
+                offset_x: shadow.offset_x as f64,
+                offset_y: shadow.offset_y as f64,
+                blur_radius: shadow.blur_radius as f64,
+            });
+        } else {
+            inner.shadow = None;
+        }
+        Ok(())
+    }
+
+    // --- Rendering ---
+
+    fn flush(&self) -> Result<(), Error> {
+        let inner = self.inner.borrow();
+        if inner.is_sub_painter {
+            return Ok(());
+        }
+        let surface = <&RbGpuSurface>::try_convert(self.surface).map_err(|_| {
+            Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                "Invalid surface reference",
+            )
+        })?;
+
+        let mut unclosed_clips = inner.clip_depth;
+        for state in &inner.state_stack {
+            unclosed_clips += state.clip_depth;
+        }
+        if unclosed_clips > 0 {
+            let mut render_scene = inner.scene.clone();
+            for _ in 0..unclosed_clips {
+                render_scene.pop_layer();
+            }
+            surface.render_and_present(&render_scene)
+        } else {
+            surface.render_and_present(&inner.scene)
+        }
+    }
+
+    fn create_sub_painter(&self) -> Result<RbPainter, Error> {
+        Ok(RbPainter {
+            surface: self.surface,
+            inner: RefCell::new(PainterInner {
+                scene: Scene::new(),
+                transform: Affine::IDENTITY,
+                fill_color: PainterInner::default_fill_color(),
+                stroke_color: PainterInner::default_stroke_color(),
+                stroke_width: 1.0,
+                font_family: None,
+                font_size: 16.0,
+                border_radius: 0.0,
+                shadow: None,
+                state_stack: Vec::new(),
+                clip_depth: 0,
+                is_sub_painter: true,
+                path: None,
+            }),
+        })
+    }
+
+    fn append(&self, sub_painter: &RbPainter, x: f64, y: f64) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        let sub_inner = sub_painter.inner.borrow();
+        let offset = Affine::translate((x, y));
+        let base_transform = inner.transform;
+        let combined = base_transform * offset;
+        let transform = if combined == Affine::IDENTITY {
+            None
+        } else {
+            Some(combined)
+        };
+        inner.scene.append(&sub_inner.scene, transform);
+        Ok(())
+    }
+
+    fn reset(&self) -> Result<(), Error> {
+        let mut inner = self.inner.borrow_mut();
+        inner.scene.reset();
+        inner.transform = Affine::IDENTITY;
+        inner.fill_color = PainterInner::default_fill_color();
+        inner.stroke_color = PainterInner::default_stroke_color();
+        inner.stroke_width = 1.0;
+        inner.font_family = None;
+        inner.font_size = 16.0;
+        inner.border_radius = 0.0;
+        inner.shadow = None;
+        inner.state_stack.clear();
+        inner.clip_depth = 0;
+        inner.path = None;
+        Ok(())
+    }
+}
+
+// --- Image loading ---
+
+fn load_image(path: &str, use_cache: bool) -> Result<peniko::ImageData, Error> {
+    let ruby = unsafe { Ruby::get_unchecked() };
+
+    if use_cache {
+        let cached = IMAGE_CACHE.with(|cache| cache.borrow().get(path).map(|c| c.data.clone()));
+        if let Some(data) = cached {
+            return Ok(data);
+        }
+    }
+
+    let img = image::open(path)
+        .map_err(|e| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                format!("Failed to load image '{}': {}", path, e),
+            )
+        })?
+        .into_rgba8();
+
+    let width = img.width();
+    let height = img.height();
+    let data = peniko::ImageData {
+        data: peniko::Blob::new(std::sync::Arc::new(img.into_raw())),
+        format: peniko::ImageFormat::Rgba8,
+        alpha_type: peniko::ImageAlphaType::Alpha,
+        width,
+        height,
+    };
+
+    if use_cache {
+        IMAGE_CACHE.with(|cache| {
+            cache.borrow_mut().insert(
+                path.to_string(),
+                CachedImage {
+                    data: data.clone(),
+                },
+            );
+        });
+    }
+
+    Ok(data)
+}
+
+// --- PainterStyle ---
+
+#[magnus::wrap(class = "Ranma::PainterStyle", free_immediately, size)]
+pub struct RbPainterStyle {
+    fill_color: Option<String>,
+    stroke_color: Option<String>,
+    stroke_width: f32,
+    font_family: Option<String>,
+    font_size: f32,
+    border_radius: f32,
+    shadow: Option<RbPainterShadowData>,
+}
+
+unsafe impl Send for RbPainterStyle {}
+
+#[derive(Clone)]
+struct RbPainterShadowData {
+    color: String,
+    offset_x: f32,
+    offset_y: f32,
+    blur_radius: f32,
+}
+
+impl RbPainterStyle {
+    fn new(opts: Option<RHash>) -> Result<Self, Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let mut style = RbPainterStyle {
+            fill_color: None,
+            stroke_color: None,
+            stroke_width: 1.0,
+            font_family: None,
+            font_size: 16.0,
+            border_radius: 0.0,
+            shadow: None,
+        };
+
+        if let Some(opts) = opts {
+            if let Some(v) = opts.get(ruby.sym_new("fill_color")) {
+                style.fill_color = String::try_convert(v).ok();
+            }
+            if let Some(v) = opts.get(ruby.sym_new("stroke_color")) {
+                style.stroke_color = String::try_convert(v).ok();
+            }
+            if let Some(v) = opts.get(ruby.sym_new("stroke_width")) {
+                if let Ok(w) = f64::try_convert(v) {
+                    style.stroke_width = w as f32;
+                }
+            }
+            if let Some(v) = opts.get(ruby.sym_new("font_family")) {
+                style.font_family = String::try_convert(v).ok();
+            }
+            if let Some(v) = opts.get(ruby.sym_new("font_size")) {
+                if let Ok(s) = f64::try_convert(v) {
+                    style.font_size = s as f32;
+                }
+            }
+            if let Some(v) = opts.get(ruby.sym_new("border_radius")) {
+                if let Ok(r) = f64::try_convert(v) {
+                    style.border_radius = r as f32;
+                }
+            }
+            if let Some(v) = opts.get(ruby.sym_new("shadow")) {
+                if let Ok(shadow) = <&RbPainterShadow>::try_convert(v) {
+                    style.shadow = Some(RbPainterShadowData {
+                        color: shadow.color.clone(),
+                        offset_x: shadow.offset_x,
+                        offset_y: shadow.offset_y,
+                        blur_radius: shadow.blur_radius,
+                    });
+                }
+            }
+        }
+
+        Ok(style)
+    }
+
+    fn fill_color(&self) -> Option<String> {
+        self.fill_color.clone()
+    }
+
+    fn stroke_color(&self) -> Option<String> {
+        self.stroke_color.clone()
+    }
+
+    fn stroke_width(&self) -> f32 {
+        self.stroke_width
+    }
+
+    fn font_family(&self) -> Option<String> {
+        self.font_family.clone()
+    }
+
+    fn font_size(&self) -> f32 {
+        self.font_size
+    }
+
+    fn border_radius(&self) -> f32 {
+        self.border_radius
+    }
+}
+
+// --- PainterShadow ---
+
+#[magnus::wrap(class = "Ranma::PainterShadow", free_immediately, size)]
+pub struct RbPainterShadow {
+    color: String,
+    offset_x: f32,
+    offset_y: f32,
+    blur_radius: f32,
+}
+
+unsafe impl Send for RbPainterShadow {}
+
+impl RbPainterShadow {
+    fn new(opts: Option<RHash>) -> Result<Self, Error> {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let mut shadow = RbPainterShadow {
+            color: "#00000040".to_string(),
+            offset_x: 0.0,
+            offset_y: 0.0,
+            blur_radius: 0.0,
+        };
+
+        if let Some(opts) = opts {
+            if let Some(v) = opts.get(ruby.sym_new("color")) {
+                if let Ok(c) = String::try_convert(v) {
+                    shadow.color = c;
+                }
+            }
+            if let Some(v) = opts.get(ruby.sym_new("offset_x")) {
+                if let Ok(x) = f64::try_convert(v) {
+                    shadow.offset_x = x as f32;
+                }
+            }
+            if let Some(v) = opts.get(ruby.sym_new("offset_y")) {
+                if let Ok(y) = f64::try_convert(v) {
+                    shadow.offset_y = y as f32;
+                }
+            }
+            if let Some(v) = opts.get(ruby.sym_new("blur_radius")) {
+                if let Ok(r) = f64::try_convert(v) {
+                    shadow.blur_radius = r as f32;
+                }
+            }
+        }
+
+        Ok(shadow)
+    }
+
+    fn color(&self) -> String {
+        self.color.clone()
+    }
+
+    fn offset_x(&self) -> f32 {
+        self.offset_x
+    }
+
+    fn offset_y(&self) -> f32 {
+        self.offset_y
+    }
+
+    fn blur_radius(&self) -> f32 {
+        self.blur_radius
+    }
+}
+
+// --- PainterFontMetrics ---
+
+#[magnus::wrap(class = "Ranma::PainterFontMetrics", free_immediately, size)]
+pub struct RbPainterFontMetrics {
+    ascent: f32,
+    descent: f32,
+    leading: f32,
+    height: f32,
+}
+
+unsafe impl Send for RbPainterFontMetrics {}
+
+impl RbPainterFontMetrics {
+    fn ascent(&self) -> f32 {
+        self.ascent
+    }
+
+    fn descent(&self) -> f32 {
+        self.descent
+    }
+
+    fn leading(&self) -> f32 {
+        self.leading
+    }
+
+    fn height(&self) -> f32 {
+        self.height
+    }
+}
+
+// --- Define classes ---
+
+pub fn define_painter_classes(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    // PainterShadow
+    let shadow_class = module.define_class("PainterShadow", ruby.class_object())?;
+    shadow_class.define_singleton_method("new", function!(RbPainterShadow::new, 1))?;
+    shadow_class.define_method("color", method!(RbPainterShadow::color, 0))?;
+    shadow_class.define_method("offset_x", method!(RbPainterShadow::offset_x, 0))?;
+    shadow_class.define_method("offset_y", method!(RbPainterShadow::offset_y, 0))?;
+    shadow_class.define_method("blur_radius", method!(RbPainterShadow::blur_radius, 0))?;
+
+    // PainterStyle
+    let style_class = module.define_class("PainterStyle", ruby.class_object())?;
+    style_class.define_singleton_method("new", function!(RbPainterStyle::new, 1))?;
+    style_class.define_method("fill_color", method!(RbPainterStyle::fill_color, 0))?;
+    style_class.define_method("stroke_color", method!(RbPainterStyle::stroke_color, 0))?;
+    style_class.define_method("stroke_width", method!(RbPainterStyle::stroke_width, 0))?;
+    style_class.define_method("font_family", method!(RbPainterStyle::font_family, 0))?;
+    style_class.define_method("font_size", method!(RbPainterStyle::font_size, 0))?;
+    style_class.define_method("border_radius", method!(RbPainterStyle::border_radius, 0))?;
+
+    // PainterFontMetrics
+    let metrics_class = module.define_class("PainterFontMetrics", ruby.class_object())?;
+    metrics_class.define_method("ascent", method!(RbPainterFontMetrics::ascent, 0))?;
+    metrics_class.define_method("descent", method!(RbPainterFontMetrics::descent, 0))?;
+    metrics_class.define_method("leading", method!(RbPainterFontMetrics::leading, 0))?;
+    metrics_class.define_method("height", method!(RbPainterFontMetrics::height, 0))?;
+
+    // Painter
+    let painter_class = module.define_class("Painter", ruby.class_object())?;
+    painter_class.define_singleton_method("new", function!(RbPainter::new, 1))?;
+    painter_class.define_method("clear_all", method!(RbPainter::clear_all, 1))?;
+    painter_class.define_method("fill_rect", method!(RbPainter::fill_rect, 4))?;
+    painter_class.define_method("stroke_rect", method!(RbPainter::stroke_rect, 4))?;
+    painter_class.define_method("fill_circle", method!(RbPainter::fill_circle, 3))?;
+    painter_class.define_method("stroke_circle", method!(RbPainter::stroke_circle, 3))?;
+    painter_class.define_method("fill_text", method!(RbPainter::fill_text, 4))?;
+    painter_class.define_method("measure_text", method!(RbPainter::measure_text, 1))?;
+    painter_class.define_method("get_font_metrics", method!(RbPainter::get_font_metrics, 0))?;
+    painter_class.define_method("draw_image", method!(RbPainter::draw_image, 5))?;
+    painter_class.define_method("measure_image", method!(RbPainter::measure_image, 1))?;
+    painter_class.define_method("draw_caret", method!(RbPainter::draw_caret, 3))?;
+    painter_class.define_method("save", method!(RbPainter::save, 0))?;
+    painter_class.define_method("restore", method!(RbPainter::restore, 0))?;
+    painter_class.define_method("translate", method!(RbPainter::translate, 2))?;
+    painter_class.define_method("scale", method!(RbPainter::scale, 2))?;
+    painter_class.define_method("clip", method!(RbPainter::clip, 4))?;
+    painter_class.define_method("style", method!(RbPainter::style, 1))?;
+    painter_class.define_method("flush", method!(RbPainter::flush, 0))?;
+    painter_class.define_method("create_sub_painter", method!(RbPainter::create_sub_painter, 0))?;
+    painter_class.define_method("append", method!(RbPainter::append, 3))?;
+    painter_class.define_method("reset", method!(RbPainter::reset, 0))?;
+    painter_class.define_method("draw_line", method!(RbPainter::draw_line, 4))?;
+    painter_class.define_method("fill_arc", method!(RbPainter::fill_arc, 5))?;
+    painter_class.define_method("stroke_arc", method!(RbPainter::stroke_arc, 5))?;
+    painter_class.define_method("fill_triangle", method!(RbPainter::fill_triangle, 6))?;
+    painter_class.define_method("begin_path", method!(RbPainter::begin_path, 0))?;
+    painter_class.define_method("path_move_to", method!(RbPainter::path_move_to, 2))?;
+    painter_class.define_method("path_line_to", method!(RbPainter::path_line_to, 2))?;
+    painter_class.define_method("fill_path", method!(RbPainter::fill_path, 0))?;
+    painter_class.define_method("close_fill_path", method!(RbPainter::close_fill_path, 0))?;
+    painter_class.define_method("measure_text_with_font", method!(RbPainter::measure_text_with_font, 3))?;
+    painter_class.define_method("get_font_metrics_with_font", method!(RbPainter::get_font_metrics_with_font, 2))?;
+
+    Ok(())
+}