runmat_plot/export/

cpu_surface.rs

use crate::core::{Camera, ImageData, PipelineType, ProjectionType, RenderData};
use crate::plots::surface::ColorMap;
use crate::plots::{AxesKind, Figure, PlotElement};
use crate::styling::PlotThemeConfig;
use font8x8::{UnicodeFonts, BASIC_FONTS};
use glam::{Vec2, Vec3, Vec4};

#[derive(Clone, Debug)]
struct AxesView {
    viewport: (u32, u32, u32, u32),
    plot_rect: (u32, u32, u32, u32),
    bounds_2d: (f32, f32, f32, f32),
    bounds_3d: (Vec3, Vec3),
    camera_3d: Option<Camera>,
    has_3d_content: bool,
    title: Option<String>,
    subtitle: Option<String>,
    x_label: Option<String>,
    y_label: Option<String>,
    z_label: Option<String>,
    x_ticks: Option<Vec<f64>>,
    y_ticks: Option<Vec<f64>>,
    x_tick_format: Option<String>,
    y_tick_format: Option<String>,
    x_tick_label_rotation: f64,
    y_tick_label_rotation: f64,
    title_scale: u32,
    label_scale: u32,
    tick_scale: u32,
    show_grid: bool,
    show_minor_grid: bool,
    show_box: bool,
    axes_kind: AxesKind,
    colorbar_enabled: bool,
    colormap: ColorMap,
}

#[derive(Clone, Debug, Default)]
struct AxesTextLabels {
    title: Option<String>,
    subtitle: Option<String>,
    x_label: Option<String>,
    y_label: Option<String>,
    z_label: Option<String>,
}

#[derive(Clone, Copy, Debug)]
struct ScreenVertex {
    x: f32,
    y: f32,
    z: f32,
    color: [u8; 4],
}

#[derive(Clone, Copy, Debug)]
struct BitmapTextAnchor {
    x: i32,
    y: i32,
    frac_x: f32,
    frac_y: f32,
}

struct Canvas {
    width: u32,
    height: u32,
    pixels: Vec<u8>,
    depth: Vec<f32>,
}

impl Canvas {
    fn new(width: u32, height: u32, background: [u8; 4]) -> Self {
        let mut pixels = vec![0u8; (width.max(1) * height.max(1) * 4) as usize];
        for px in pixels.chunks_exact_mut(4) {
            px.copy_from_slice(&background);
        }
        let depth = vec![f32::INFINITY; (width.max(1) * height.max(1)) as usize];
        Self {
            width: width.max(1),
            height: height.max(1),
            pixels,
            depth,
        }
    }

    fn rgba(self) -> Vec<u8> {
        self.pixels
    }

    fn blend_pixel(&mut self, x: i32, y: i32, rgba: [u8; 4], depth: f32, use_depth: bool) {
        if x < 0 || y < 0 || x >= self.width as i32 || y >= self.height as i32 {
            return;
        }
        let idx = (y as u32 * self.width + x as u32) as usize;
        if use_depth {
            if !depth.is_finite() || depth >= self.depth[idx] {
                return;
            }
            self.depth[idx] = depth;
        }

        let p = idx * 4;
        let src_a = rgba[3] as f32 / 255.0;
        let dst_a = self.pixels[p + 3] as f32 / 255.0;
        let out_a = src_a + dst_a * (1.0 - src_a);
        if out_a <= f32::EPSILON {
            self.pixels[p..p + 4].copy_from_slice(&[0, 0, 0, 0]);
            return;
        }
        for (i, src_u8) in rgba.iter().take(3).enumerate() {
            let src = *src_u8 as f32 / 255.0;
            let dst = self.pixels[p + i] as f32 / 255.0;
            let out = (src * src_a + dst * dst_a * (1.0 - src_a)) / out_a;
            self.pixels[p + i] = (out.clamp(0.0, 1.0) * 255.0) as u8;
        }
        self.pixels[p + 3] = (out_a.clamp(0.0, 1.0) * 255.0) as u8;
    }

    fn draw_disc(&mut self, center: Vec2, radius: f32, rgba: [u8; 4], depth: f32, use_depth: bool) {
        let r = radius.max(0.5);
        let min_x = (center.x - r).floor() as i32;
        let max_x = (center.x + r).ceil() as i32;
        let min_y = (center.y - r).floor() as i32;
        let max_y = (center.y + r).ceil() as i32;
        let rr = r * r;
        for y in min_y..=max_y {
            for x in min_x..=max_x {
                let dx = x as f32 + 0.5 - center.x;
                let dy = y as f32 + 0.5 - center.y;
                if dx * dx + dy * dy <= rr {
                    self.blend_pixel(x, y, rgba, depth, use_depth);
                }
            }
        }
    }

    fn fill_rect(&mut self, x: i32, y: i32, w: i32, h: i32, rgba: [u8; 4]) {
        if w <= 0 || h <= 0 {
            return;
        }
        let x0 = x.max(0);
        let y0 = y.max(0);
        let x1 = (x + w).min(self.width as i32);
        let y1 = (y + h).min(self.height as i32);
        for yy in y0..y1 {
            for xx in x0..x1 {
                self.blend_pixel(xx, yy, rgba, 0.0, false);
            }
        }
    }

    fn stroke_rect(&mut self, x: i32, y: i32, w: i32, h: i32, rgba: [u8; 4], width_px: f32) {
        let l = x as f32;
        let r = (x + w - 1) as f32;
        let t = y as f32;
        let b = (y + h - 1) as f32;
        let c = rgba;
        self.draw_line(
            ScreenVertex {
                x: l,
                y: t,
                z: 0.0,
                color: c,
            },
            ScreenVertex {
                x: r,
                y: t,
                z: 0.0,
                color: c,
            },
            width_px,
            0,
            false,
        );
        self.draw_line(
            ScreenVertex {
                x: r,
                y: t,
                z: 0.0,
                color: c,
            },
            ScreenVertex {
                x: r,
                y: b,
                z: 0.0,
                color: c,
            },
            width_px,
            0,
            false,
        );
        self.draw_line(
            ScreenVertex {
                x: r,
                y: b,
                z: 0.0,
                color: c,
            },
            ScreenVertex {
                x: l,
                y: b,
                z: 0.0,
                color: c,
            },
            width_px,
            0,
            false,
        );
        self.draw_line(
            ScreenVertex {
                x: l,
                y: b,
                z: 0.0,
                color: c,
            },
            ScreenVertex {
                x: l,
                y: t,
                z: 0.0,
                color: c,
            },
            width_px,
            0,
            false,
        );
    }

    fn draw_line(
        &mut self,
        a: ScreenVertex,
        b: ScreenVertex,
        width_px: f32,
        style_code: i32,
        use_depth: bool,
    ) {
        let radius = width_px.max(1.0) * 0.5;
        let segments = dash_segments(a, b, style_code, radius.max(1.0));
        for (s0, s1) in segments {
            self.draw_capsule_segment(s0, s1, radius, use_depth);
        }
    }

    fn draw_capsule_segment(
        &mut self,
        a: ScreenVertex,
        b: ScreenVertex,
        radius: f32,
        use_depth: bool,
    ) {
        let min_x = (a.x.min(b.x) - radius - 1.0).floor() as i32;
        let max_x = (a.x.max(b.x) + radius + 1.0).ceil() as i32;
        let min_y = (a.y.min(b.y) - radius - 1.0).floor() as i32;
        let max_y = (a.y.max(b.y) + radius + 1.0).ceil() as i32;

        let av = Vec2::new(a.x, a.y);
        let bv = Vec2::new(b.x, b.y);
        let ab = bv - av;
        let ab_len2 = ab.length_squared().max(1e-8);

        for y in min_y..=max_y {
            for x in min_x..=max_x {
                let p = Vec2::new(x as f32 + 0.5, y as f32 + 0.5);
                let t = ((p - av).dot(ab) / ab_len2).clamp(0.0, 1.0);
                let closest = av + ab * t;
                let dist = p.distance(closest);
                if dist > radius + 1.0 {
                    continue;
                }
                let coverage = (radius + 1.0 - dist).clamp(0.0, 1.0);
                if coverage <= 0.0 {
                    continue;
                }

                let depth = a.z + (b.z - a.z) * t;
                let mut color = lerp_rgba(a.color, b.color, t);
                color[3] = ((color[3] as f32) * coverage).round().clamp(0.0, 255.0) as u8;
                self.blend_pixel(x, y, color, depth, use_depth);
            }
        }
    }

    fn fill_triangle(
        &mut self,
        v0: ScreenVertex,
        v1: ScreenVertex,
        v2: ScreenVertex,
        use_depth: bool,
    ) {
        let min_x = v0.x.min(v1.x).min(v2.x).floor() as i32;
        let max_x = v0.x.max(v1.x).max(v2.x).ceil() as i32;
        let min_y = v0.y.min(v1.y).min(v2.y).floor() as i32;
        let max_y = v0.y.max(v1.y).max(v2.y).ceil() as i32;

        let p0 = Vec2::new(v0.x, v0.y);
        let p1 = Vec2::new(v1.x, v1.y);
        let p2 = Vec2::new(v2.x, v2.y);
        let area = edge_fn(p0, p1, p2);
        if area.abs() <= f32::EPSILON {
            return;
        }

        for y in min_y..=max_y {
            for x in min_x..=max_x {
                let p = Vec2::new(x as f32 + 0.5, y as f32 + 0.5);
                let w0 = edge_fn(p1, p2, p) / area;
                let w1 = edge_fn(p2, p0, p) / area;
                let w2 = edge_fn(p0, p1, p) / area;
                if w0 < 0.0 || w1 < 0.0 || w2 < 0.0 {
                    continue;
                }
                let depth = w0 * v0.z + w1 * v1.z + w2 * v2.z;
                let color = blend_barycentric_rgba(v0.color, v1.color, v2.color, w0, w1, w2);
                self.blend_pixel(x, y, color, depth, use_depth);
            }
        }
    }
}

fn edge_fn(a: Vec2, b: Vec2, c: Vec2) -> f32 {
    (c.x - a.x) * (b.y - a.y) - (c.y - a.y) * (b.x - a.x)
}

fn blend_barycentric_rgba(
    c0: [u8; 4],
    c1: [u8; 4],
    c2: [u8; 4],
    w0: f32,
    w1: f32,
    w2: f32,
) -> [u8; 4] {
    let mix = |a: u8, b: u8, c: u8| -> u8 {
        (a as f32 * w0 + b as f32 * w1 + c as f32 * w2)
            .round()
            .clamp(0.0, 255.0) as u8
    };
    [
        mix(c0[0], c1[0], c2[0]),
        mix(c0[1], c1[1], c2[1]),
        mix(c0[2], c1[2], c2[2]),
        mix(c0[3], c1[3], c2[3]),
    ]
}

fn lerp_rgba(a: [u8; 4], b: [u8; 4], t: f32) -> [u8; 4] {
    let mix = |x: u8, y: u8| -> u8 {
        (x as f32 + (y as f32 - x as f32) * t)
            .round()
            .clamp(0.0, 255.0) as u8
    };
    [
        mix(a[0], b[0]),
        mix(a[1], b[1]),
        mix(a[2], b[2]),
        mix(a[3], b[3]),
    ]
}

fn with_alpha(color: [u8; 4], alpha_scale: f32) -> [u8; 4] {
    let mut out = color;
    out[3] = ((out[3] as f32) * alpha_scale).round().clamp(0.0, 255.0) as u8;
    out
}

fn dash_segments(
    a: ScreenVertex,
    b: ScreenVertex,
    style_code: i32,
    width_px: f32,
) -> Vec<(ScreenVertex, ScreenVertex)> {
    let dx = b.x - a.x;
    let dy = b.y - a.y;
    let len = (dx * dx + dy * dy).sqrt();
    if len <= 1e-5 {
        return vec![(a, b)];
    }
    let pattern = match style_code {
        1 => vec![(6.0 * width_px, true), (6.0 * width_px, false)],
        2 => vec![(1.5 * width_px, true), (5.0 * width_px, false)],
        3 => vec![
            (6.0 * width_px, true),
            (4.0 * width_px, false),
            (1.5 * width_px, true),
            (4.0 * width_px, false),
        ],
        _ => return vec![(a, b)],
    };

    let mut out = Vec::new();
    let mut s = 0.0f32;
    let mut pi = 0usize;
    while s < len {
        let (step, draw) = pattern[pi % pattern.len()];
        let e = (s + step.max(1.0)).min(len);
        if draw {
            let t0 = s / len;
            let t1 = e / len;
            out.push((lerp_screen(a, b, t0), lerp_screen(a, b, t1)));
        }
        s = e;
        pi += 1;
    }
    out
}

fn lerp_screen(a: ScreenVertex, b: ScreenVertex, t: f32) -> ScreenVertex {
    ScreenVertex {
        x: a.x + (b.x - a.x) * t,
        y: a.y + (b.y - a.y) * t,
        z: a.z + (b.z - a.z) * t,
        color: lerp_rgba(a.color, b.color, t),
    }
}

fn to_u8_rgba(color: [f32; 4]) -> [u8; 4] {
    [
        (color[0].clamp(0.0, 1.0) * 255.0) as u8,
        (color[1].clamp(0.0, 1.0) * 255.0) as u8,
        (color[2].clamp(0.0, 1.0) * 255.0) as u8,
        (color[3].clamp(0.0, 1.0) * 255.0) as u8,
    ]
}

fn is_default_figure_bg(bg: Vec4) -> bool {
    const EPS: f32 = 1e-3;
    (bg.x - 1.0).abs() <= EPS
        && (bg.y - 1.0).abs() <= EPS
        && (bg.z - 1.0).abs() <= EPS
        && (bg.w - 1.0).abs() <= EPS
}

fn compute_tiled_viewports(
    width: u32,
    height: u32,
    rows: usize,
    cols: usize,
) -> Vec<(u32, u32, u32, u32)> {
    if rows == 0 || cols == 0 {
        return vec![(0, 0, width.max(1), height.max(1))];
    }
    let rows_u = rows as u32;
    let cols_u = cols as u32;
    let cell_w = (width / cols_u).max(1);
    let cell_h = (height / rows_u).max(1);
    let mut out = Vec::with_capacity(rows * cols);
    for r in 0..rows_u {
        for c in 0..cols_u {
            let x = c * cell_w;
            let y = r * cell_h;
            let w = if c + 1 == cols_u {
                width.saturating_sub(x).max(1)
            } else {
                cell_w
            };
            let h = if r + 1 == rows_u {
                height.saturating_sub(y).max(1)
            } else {
                cell_h
            };
            out.push((x, y, w, h));
        }
    }
    out
}

fn rotation_margin(angle_degrees: f64, margin: u32) -> u32 {
    if angle_degrees.abs() <= f64::EPSILON {
        0
    } else {
        margin
    }
}

fn compute_plot_rect(
    viewport: (u32, u32, u32, u32),
    has_3d: bool,
    x_tick_label_rotation: f64,
    y_tick_label_rotation: f64,
) -> (u32, u32, u32, u32) {
    let (vx, vy, vw, vh) = viewport;
    let left = if has_3d {
        48
    } else {
        62 + rotation_margin(y_tick_label_rotation, 24)
    };
    let right = 24;
    let top = if has_3d { 34 } else { 40 };
    let bottom = if has_3d {
        48
    } else {
        54 + rotation_margin(x_tick_label_rotation, 32)
    };

    let px = vx + left.min(vw.saturating_sub(2));
    let py = vy + top.min(vh.saturating_sub(2));
    let pw = vw
        .saturating_sub(left + right)
        .max(vw.saturating_sub(2).max(1));
    let ph = vh
        .saturating_sub(top + bottom)
        .max(vh.saturating_sub(2).max(1));
    (px, py, pw.max(1), ph.max(1))
}

fn square_plot_rect(rect: (u32, u32, u32, u32)) -> (u32, u32, u32, u32) {
    let (x, y, w, h) = rect;
    let size = w.min(h).max(1);
    let x = x + (w.saturating_sub(size) / 2);
    let y = y + (h.saturating_sub(size) / 2);
    (x, y, size, size)
}

fn project_2d(
    pos: Vec3,
    plot_rect: (u32, u32, u32, u32),
    bounds: (f32, f32, f32, f32),
    color: [u8; 4],
) -> ScreenVertex {
    let (x_min, x_max, y_min, y_max) = bounds;
    let xr = (x_max - x_min).max(1e-6);
    let yr = (y_max - y_min).max(1e-6);
    let tx = ((pos.x - x_min) / xr).clamp(0.0, 1.0);
    let ty = ((pos.y - y_min) / yr).clamp(0.0, 1.0);
    let sx = plot_rect.0 as f32 + tx * plot_rect.2.max(1) as f32;
    let sy = plot_rect.1 as f32 + (1.0 - ty) * plot_rect.3.max(1) as f32;
    ScreenVertex {
        x: sx,
        y: sy,
        z: 0.0,
        color,
    }
}

fn project_3d(
    pos: Vec3,
    plot_rect: (u32, u32, u32, u32),
    camera: &Camera,
    color: [u8; 4],
) -> Option<ScreenVertex> {
    let mut cam = camera.clone();
    cam.update_aspect_ratio((plot_rect.2.max(1) as f32) / (plot_rect.3.max(1) as f32));
    let vp = cam.view_proj_matrix();
    let clip = vp * pos.extend(1.0);
    if clip.w.abs() <= 1e-6 {
        return None;
    }
    let ndc = clip.truncate() / clip.w;
    if ndc.z < -1.2 || ndc.z > 1.2 {
        return None;
    }
    let sx = plot_rect.0 as f32 + (ndc.x * 0.5 + 0.5) * plot_rect.2.max(1) as f32;
    let sy = plot_rect.1 as f32 + (1.0 - (ndc.y * 0.5 + 0.5)) * plot_rect.3.max(1) as f32;
    let depth = ndc.z * 0.5 + 0.5;
    Some(ScreenVertex {
        x: sx,
        y: sy,
        z: depth,
        color,
    })
}

fn axes_has_3d_content(figure: &Figure, axes_index: usize) -> bool {
    figure
        .plots()
        .zip(figure.plot_axes_indices().iter().copied())
        .any(|(plot, idx)| {
            idx == axes_index
                && match plot {
                    PlotElement::Surface(surface) => !surface.image_mode,
                    PlotElement::Mesh(_) => true,
                    PlotElement::Patch(patch) => {
                        patch.force_3d() || patch.vertices().iter().any(|p| p.z.abs() > 1e-6)
                    }
                    PlotElement::Line3(_) | PlotElement::Scatter3(_) => true,
                    _ => false,
                }
        })
}

fn choose_axes_bounds(
    figure: &Figure,
    axes_index: usize,
    render_data: &[(usize, RenderData)],
) -> (f32, f32, f32, f32) {
    let mut min_x = f32::INFINITY;
    let mut max_x = f32::NEG_INFINITY;
    let mut min_y = f32::INFINITY;
    let mut max_y = f32::NEG_INFINITY;

    for (ax, rd) in render_data {
        if *ax != axes_index {
            continue;
        }
        if let Some(bounds) = rd.bounds {
            min_x = min_x.min(bounds.min.x);
            max_x = max_x.max(bounds.max.x);
            min_y = min_y.min(bounds.min.y);
            max_y = max_y.max(bounds.max.y);
        }
    }

    if !min_x.is_finite() || !max_x.is_finite() || !min_y.is_finite() || !max_y.is_finite() {
        min_x = -1.0;
        max_x = 1.0;
        min_y = -1.0;
        max_y = 1.0;
    }

    if let Some(meta) = figure.axes_metadata(axes_index) {
        if let Some((l, r)) = meta.x_limits {
            min_x = l as f32;
            max_x = r as f32;
        }
        if let Some((b, t)) = meta.y_limits {
            min_y = b as f32;
            max_y = t as f32;
        }
        if meta.axis_equal || meta.data_aspect_ratio_mode == "manual" {
            (min_x, max_x, min_y, max_y) =
                data_aspect_adjusted_bounds(min_x, max_x, min_y, max_y, meta.data_aspect_ratio);
        }
    }

    (min_x, max_x, min_y, max_y)
}

fn data_aspect_adjusted_bounds(
    x_min: f32,
    x_max: f32,
    y_min: f32,
    y_max: f32,
    ratio: [f64; 3],
) -> (f32, f32, f32, f32) {
    let x_ratio = (ratio[0].abs().max(1.0e-12)) as f32;
    let y_ratio = (ratio[1].abs().max(1.0e-12)) as f32;
    let cx = (x_min + x_max) * 0.5;
    let cy = (y_min + y_max) * 0.5;
    let x_span = (x_max - x_min).abs().max(0.1);
    let y_span = (y_max - y_min).abs().max(0.1);
    let units = (x_span / x_ratio).max(y_span / y_ratio).max(0.1);
    let next_x = units * x_ratio;
    let next_y = units * y_ratio;
    (
        cx - next_x * 0.5,
        cx + next_x * 0.5,
        cy - next_y * 0.5,
        cy + next_y * 0.5,
    )
}

fn choose_axes_bounds_3d(
    figure: &Figure,
    axes_index: usize,
    render_data: &[(usize, RenderData)],
    bounds_2d: (f32, f32, f32, f32),
) -> (Vec3, Vec3) {
    let mut min = Vec3::splat(f32::INFINITY);
    let mut max = Vec3::splat(f32::NEG_INFINITY);

    for (ax, rd) in render_data {
        if *ax != axes_index {
            continue;
        }
        if let Some(bounds) = rd.bounds {
            min = min.min(bounds.min);
            max = max.max(bounds.max);
        }
    }

    let (mut min, mut max) = if !min.x.is_finite() || !max.x.is_finite() {
        (
            Vec3::new(bounds_2d.0, bounds_2d.2, -1.0),
            Vec3::new(bounds_2d.1, bounds_2d.3, 1.0),
        )
    } else {
        if (max.z - min.z).abs() < 1e-6 {
            min.z -= 0.5;
            max.z += 0.5;
        }
        (min, max)
    };

    if let Some(meta) = figure.axes_metadata(axes_index) {
        if let Some((lo, hi)) = meta.x_limits {
            min.x = lo as f32;
            max.x = hi as f32;
        }
        if let Some((lo, hi)) = meta.y_limits {
            min.y = lo as f32;
            max.y = hi as f32;
        }
        if let Some((lo, hi)) = meta.z_limits {
            min.z = lo as f32;
            max.z = hi as f32;
        }
        if meta.axis_equal || meta.data_aspect_ratio_mode == "manual" {
            (min, max) = data_aspect_adjusted_bounds_3d(min, max, meta.data_aspect_ratio);
        }
    }
    (min, max)
}

fn data_aspect_adjusted_bounds_3d(min: Vec3, max: Vec3, ratio: [f64; 3]) -> (Vec3, Vec3) {
    let aspect = Vec3::new(
        ratio[0].abs().max(1.0e-12) as f32,
        ratio[1].abs().max(1.0e-12) as f32,
        ratio[2].abs().max(1.0e-12) as f32,
    );
    let center = (min + max) * 0.5;
    let span = (max - min).abs().max(Vec3::splat(0.1));
    let units = (span.x / aspect.x)
        .max(span.y / aspect.y)
        .max(span.z / aspect.z)
        .max(0.1);
    let next = aspect * units;
    (center - next * 0.5, center + next * 0.5)
}

fn default_3d_camera_for_bounds(min: Vec3, max: Vec3) -> Camera {
    let center = (min + max) * 0.5;
    let extent = (max - min).abs();
    let radius = extent.length().max(1e-3) * 0.5;

    let mut cam = Camera::new();
    let fov = match cam.projection {
        ProjectionType::Perspective { fov, .. } => fov.max(0.2),
        _ => 45.0f32.to_radians(),
    };
    let distance = (radius / (fov * 0.5).tan()).max(radius * 2.5) * 1.05;

    let dir = Vec3::new(1.0, -1.0, 0.8).normalize_or_zero();
    cam.target = center;
    cam.position = center + dir * distance;
    cam.up = Vec3::Z;
    cam
}

fn choose_axes_camera(
    figure: &Figure,
    axes_index: usize,
    axes_cameras: Option<&[Camera]>,
    min: Vec3,
    max: Vec3,
) -> Camera {
    if let Some(cams) = axes_cameras {
        if let Some(cam) = cams.get(axes_index) {
            return cam.clone();
        }
    }

    let mut cam = default_3d_camera_for_bounds(min, max);

    if let Some(meta) = figure.axes_metadata(axes_index) {
        if let (Some(az), Some(el)) = (meta.view_azimuth_deg, meta.view_elevation_deg) {
            cam.set_view_angles_deg(az, el);
        }
    }

    cam
}

fn get_axes_title_and_labels(figure: &Figure, axes_index: usize) -> AxesTextLabels {
    let meta = figure.axes_metadata(axes_index);
    let title = meta
        .and_then(|m| m.title.as_ref())
        .or(figure.title.as_ref())
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty());
    let subtitle = meta
        .and_then(|m| m.subtitle.as_ref())
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty());
    let x_label = meta
        .and_then(|m| m.x_label.as_ref())
        .or(figure.x_label.as_ref())
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty());
    let y_label = meta
        .and_then(|m| m.y_label.as_ref())
        .or(figure.y_label.as_ref())
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty());
    let z_label = meta
        .and_then(|m| m.z_label.as_ref())
        .or(figure.z_label.as_ref())
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty());
    AxesTextLabels {
        title,
        subtitle,
        x_label,
        y_label,
        z_label,
    }
}

fn text_scale_from_font_size(font_size: Option<f32>, default_scale: u32) -> u32 {
    let base = font_size.unwrap_or((default_scale.max(1) * 8) as f32);
    ((base / 8.0).round() as i32).clamp(1, 4) as u32
}

fn get_axes_style_and_display_prefs(
    figure: &Figure,
    axes_index: usize,
) -> (u32, u32, u32, bool, bool, bool) {
    let Some(meta) = figure.axes_metadata(axes_index) else {
        return (
            2,
            2,
            1,
            figure.grid_enabled,
            figure.minor_grid_enabled,
            figure.box_enabled,
        );
    };

    let title_scale = text_scale_from_font_size(
        meta.title_style.font_size.or(meta.subtitle_style.font_size),
        2,
    );
    let label_font = meta
        .x_label_style
        .font_size
        .or(meta.y_label_style.font_size)
        .or(meta.z_label_style.font_size);
    let label_scale = text_scale_from_font_size(label_font, 2);
    let tick_scale = text_scale_from_font_size(meta.axes_style.font_size, 1);

    (
        title_scale,
        label_scale,
        tick_scale,
        meta.grid_enabled,
        figure.minor_grid_enabled_for_axes(axes_index),
        meta.box_enabled,
    )
}

fn project_vertex(vertex: &crate::core::Vertex, axes: &AxesView) -> Option<ScreenVertex> {
    let pos = Vec3::from_array(vertex.position);
    let color = to_u8_rgba(vertex.color);
    if axes.has_3d_content {
        axes.camera_3d
            .as_ref()
            .and_then(|camera| project_3d(pos, axes.plot_rect, camera, color))
    } else {
        Some(project_2d(pos, axes.plot_rect, axes.bounds_2d, color))
    }
}

fn draw_bitmap_text(canvas: &mut Canvas, x: i32, y: i32, text: &str, scale: u32, color: [u8; 4]) {
    let mut cursor_x = x;
    let sc = scale.max(1) as i32;
    let fallback = BASIC_FONTS.get('?').unwrap_or([0u8; 8]);

    for ch in text.chars() {
        let glyph = BASIC_FONTS
            .get(ch)
            .or_else(|| BASIC_FONTS.get(' '))
            .unwrap_or(fallback);
        for (row, bits) in glyph.iter().enumerate() {
            for col in 0..8i32 {
                if ((bits >> col) & 1) == 0 {
                    continue;
                }
                for sy in 0..sc {
                    for sx in 0..sc {
                        canvas.blend_pixel(
                            cursor_x + col * sc + sx,
                            y + row as i32 * sc + sy,
                            color,
                            0.0,
                            false,
                        );
                    }
                }
            }
        }
        cursor_x += 8 * sc + sc;
    }
}

fn bitmap_text_size(text: &str, scale: u32) -> (i32, i32) {
    let sc = scale.max(1) as i32;
    ((text.chars().count() as i32) * (8 * sc + sc), 8 * sc)
}

fn draw_bitmap_text_rotated(
    canvas: &mut Canvas,
    anchor: BitmapTextAnchor,
    text: &str,
    scale: u32,
    color: [u8; 4],
    angle_degrees: f64,
) {
    if angle_degrees.abs() <= f64::EPSILON {
        draw_bitmap_text(canvas, anchor.x, anchor.y, text, scale, color);
        return;
    }

    let sc = scale.max(1) as i32;
    let (text_w, text_h) = bitmap_text_size(text, scale);
    let local_anchor = Vec2::new(text_w as f32 * anchor.frac_x, text_h as f32 * anchor.frac_y);
    let fallback = BASIC_FONTS.get('?').unwrap_or([0u8; 8]);
    let sin = (angle_degrees as f32).to_radians().sin();
    let cos = (angle_degrees as f32).to_radians().cos();
    let mut cursor_x = 0i32;

    for ch in text.chars() {
        let glyph = BASIC_FONTS
            .get(ch)
            .or_else(|| BASIC_FONTS.get(' '))
            .unwrap_or(fallback);
        for (row, bits) in glyph.iter().enumerate() {
            for col in 0..8i32 {
                if ((bits >> col) & 1) == 0 {
                    continue;
                }
                for sy in 0..sc {
                    for sx in 0..sc {
                        let local_x = cursor_x + col * sc + sx;
                        let local_y = row as i32 * sc + sy;
                        let local = Vec2::new(local_x as f32, local_y as f32) - local_anchor;
                        let rx = local.x * cos - local.y * sin;
                        let ry = local.x * sin + local.y * cos;
                        canvas.blend_pixel(
                            anchor.x + rx.round() as i32,
                            anchor.y + ry.round() as i32,
                            color,
                            0.0,
                            false,
                        );
                    }
                }
            }
        }
        cursor_x += 8 * sc + sc;
    }
}

fn draw_tick_text(
    canvas: &mut Canvas,
    anchor: BitmapTextAnchor,
    text: &str,
    scale: u32,
    color: [u8; 4],
    angle_degrees: f64,
) {
    let (text_w, text_h) = bitmap_text_size(text, scale);
    if angle_degrees.abs() <= f64::EPSILON {
        draw_bitmap_text(
            canvas,
            anchor.x - (text_w as f32 * anchor.frac_x).round() as i32,
            anchor.y - (text_h as f32 * anchor.frac_y).round() as i32,
            text,
            scale,
            color,
        );
    } else {
        draw_bitmap_text_rotated(canvas, anchor, text, scale, color, angle_degrees);
    }
}

fn draw_text_centered(
    canvas: &mut Canvas,
    center_x: i32,
    y: i32,
    text: &str,
    scale: u32,
    color: [u8; 4],
) {
    let sc = scale.max(1) as i32;
    let text_w = (text.chars().count() as i32) * (8 * sc + sc);
    let x = center_x - text_w / 2;
    draw_bitmap_text(canvas, x, y, text, scale, color);
}

fn draw_2d_axes_decorations(canvas: &mut Canvas, axes: &AxesView) {
    let frame_color = [162, 170, 184, 255];
    let grid_color = [104, 114, 130, 110];
    let minor_grid_color = [104, 114, 130, 56];
    let text_color = [212, 220, 234, 255];

    let (px, py, pw, ph) = axes.plot_rect;
    let left = px as i32;
    let right = (px + pw.saturating_sub(1)) as i32;
    let top = py as i32;
    let bottom = (py + ph.saturating_sub(1)) as i32;

    if axes.axes_kind == AxesKind::Polar {
        draw_polar_axes_decorations(
            canvas,
            axes,
            (left, right, top, bottom),
            grid_color,
            minor_grid_color,
            frame_color,
            text_color,
        );
        draw_axes_titles_and_labels(canvas, axes, text_color);
        return;
    }

    let (x_min, x_max, y_min, y_max) = axes.bounds_2d;
    let data_to_x = |value: f32| -> Option<i32> {
        if value < x_min || value > x_max {
            return None;
        }
        let span = x_max - x_min;
        if !span.is_finite() || span.abs() <= f32::EPSILON {
            return None;
        }
        let t = (value - x_min) / span;
        Some((left as f32 + t * (right - left) as f32).round() as i32)
    };
    let data_to_y = |value: f32| -> Option<i32> {
        if value < y_min || value > y_max {
            return None;
        }
        let span = y_max - y_min;
        if !span.is_finite() || span.abs() <= f32::EPSILON {
            return None;
        }
        let t = (y_max - value) / span;
        Some((top as f32 + t * (bottom - top) as f32).round() as i32)
    };

    if axes.show_minor_grid {
        let subdivisions = 5;
        for i in 0..=(6 * subdivisions) {
            if i % subdivisions == 0 {
                continue;
            }
            let t = i as f32 / (6 * subdivisions) as f32;
            let x = (left as f32 + t * (right - left) as f32).round() as i32;
            let y = (top as f32 + t * (bottom - top) as f32).round() as i32;

            canvas.draw_line(
                ScreenVertex {
                    x: x as f32,
                    y: top as f32,
                    z: 0.0,
                    color: minor_grid_color,
                },
                ScreenVertex {
                    x: x as f32,
                    y: bottom as f32,
                    z: 0.0,
                    color: minor_grid_color,
                },
                0.8,
                0,
                false,
            );
            canvas.draw_line(
                ScreenVertex {
                    x: left as f32,
                    y: y as f32,
                    z: 0.0,
                    color: minor_grid_color,
                },
                ScreenVertex {
                    x: right as f32,
                    y: y as f32,
                    z: 0.0,
                    color: minor_grid_color,
                },
                0.8,
                0,
                false,
            );
        }
    }

    if axes.show_grid {
        let x_grid: Vec<i32> = axes
            .x_ticks
            .as_ref()
            .map(|ticks| {
                ticks
                    .iter()
                    .filter_map(|value| data_to_x(*value as f32))
                    .collect()
            })
            .unwrap_or_else(|| {
                (0..=6)
                    .map(|i| {
                        let t = i as f32 / 6.0;
                        (left as f32 + t * (right - left) as f32).round() as i32
                    })
                    .collect()
            });
        for x in x_grid {
            let gv = ScreenVertex {
                x: x as f32,
                y: top as f32,
                z: 0.0,
                color: grid_color,
            };
            let gv2 = ScreenVertex {
                x: x as f32,
                y: bottom as f32,
                z: 0.0,
                color: grid_color,
            };
            canvas.draw_line(gv, gv2, 1.0, 0, false);
        }

        let y_grid: Vec<i32> = axes
            .y_ticks
            .as_ref()
            .map(|ticks| {
                ticks
                    .iter()
                    .filter_map(|value| data_to_y(*value as f32))
                    .collect()
            })
            .unwrap_or_else(|| {
                (0..=6)
                    .map(|i| {
                        let t = i as f32 / 6.0;
                        (top as f32 + t * (bottom - top) as f32).round() as i32
                    })
                    .collect()
            });
        for y in y_grid {
            let gh = ScreenVertex {
                x: left as f32,
                y: y as f32,
                z: 0.0,
                color: grid_color,
            };
            let gh2 = ScreenVertex {
                x: right as f32,
                y: y as f32,
                z: 0.0,
                color: grid_color,
            };
            canvas.draw_line(gh, gh2, 1.0, 0, false);
        }
    }

    if axes.show_box {
        let corners = [
            (left as f32, top as f32),
            (right as f32, top as f32),
            (right as f32, bottom as f32),
            (left as f32, bottom as f32),
        ];
        for i in 0..4 {
            let a = corners[i];
            let b = corners[(i + 1) % 4];
            canvas.draw_line(
                ScreenVertex {
                    x: a.0,
                    y: a.1,
                    z: 0.0,
                    color: frame_color,
                },
                ScreenVertex {
                    x: b.0,
                    y: b.1,
                    z: 0.0,
                    color: frame_color,
                },
                1.2,
                0,
                false,
            );
        }
    }

    let tick_sc = axes.tick_scale as i32;
    let x_tick_formatter = crate::core::plot_renderer::plot_utils::TickLabelFormatter::new(
        axes.x_tick_format.as_deref(),
    );
    let y_tick_formatter = crate::core::plot_renderer::plot_utils::TickLabelFormatter::new(
        axes.y_tick_format.as_deref(),
    );
    let x_ticks = axes
        .x_ticks
        .as_ref()
        .map(|ticks| ticks.iter().map(|value| *value as f32).collect::<Vec<_>>())
        .unwrap_or_else(|| {
            (0..=4)
                .map(|i| x_min + (i as f32 / 4.0) * (x_max - x_min))
                .collect()
        });
    for xv in x_ticks {
        if xv < x_min || xv > x_max {
            continue;
        }
        let t = (xv - x_min) / (x_max - x_min).max(f32::EPSILON);
        let x = (left as f32 + t * (right - left) as f32).round() as i32;
        draw_tick_text(
            canvas,
            BitmapTextAnchor {
                x,
                y: bottom + 6 + tick_sc,
                frac_x: 0.5,
                frac_y: 0.0,
            },
            &x_tick_formatter.format(xv as f64),
            axes.tick_scale,
            with_alpha(text_color, 0.9),
            axes.x_tick_label_rotation,
        );
    }
    let y_ticks = axes
        .y_ticks
        .as_ref()
        .map(|ticks| ticks.iter().map(|value| *value as f32).collect::<Vec<_>>())
        .unwrap_or_else(|| {
            (0..=4)
                .map(|i| y_max - (i as f32 / 4.0) * (y_max - y_min))
                .collect()
        });
    for yv in y_ticks {
        if yv < y_min || yv > y_max {
            continue;
        }
        let t = (y_max - yv) / (y_max - y_min).max(f32::EPSILON);
        let y = (top as f32 + t * (bottom - top) as f32).round() as i32;
        draw_tick_text(
            canvas,
            BitmapTextAnchor {
                x: left - 8 * tick_sc,
                y,
                frac_x: 1.0,
                frac_y: 0.5,
            },
            &y_tick_formatter.format(yv as f64),
            axes.tick_scale,
            with_alpha(text_color, 0.9),
            axes.y_tick_label_rotation,
        );
    }

    draw_axes_titles_and_labels(canvas, axes, text_color);
}

fn draw_axes_titles_and_labels(canvas: &mut Canvas, axes: &AxesView, text_color: [u8; 4]) {
    if let Some(title) = &axes.title {
        draw_text_centered(
            canvas,
            (axes.viewport.0 + axes.viewport.2 / 2) as i32,
            axes.viewport.1 as i32 + 6,
            title,
            axes.title_scale,
            text_color,
        );
    }
    if let Some(subtitle) = &axes.subtitle {
        draw_text_centered(
            canvas,
            (axes.viewport.0 + axes.viewport.2 / 2) as i32,
            axes.viewport.1 as i32 + 8 + (10 * axes.title_scale) as i32,
            subtitle,
            axes.title_scale.saturating_sub(1).max(1),
            with_alpha(text_color, 0.9),
        );
    }
    if let Some(x_label) = &axes.x_label {
        let label_sc = axes.label_scale as i32;
        draw_text_centered(
            canvas,
            (axes.viewport.0 + axes.viewport.2 / 2) as i32,
            (axes.viewport.1 + axes.viewport.3).saturating_sub((12 + 10 * label_sc) as u32) as i32,
            x_label,
            axes.label_scale,
            text_color,
        );
    }
    if let Some(y_label) = &axes.y_label {
        let label_sc = axes.label_scale as i32;
        draw_bitmap_text(
            canvas,
            axes.viewport.0 as i32 + 6,
            (axes.viewport.1 + axes.viewport.3 / 2).saturating_sub((8 * label_sc) as u32) as i32,
            y_label,
            axes.label_scale,
            text_color,
        );
    }
}

fn draw_polar_axes_decorations(
    canvas: &mut Canvas,
    axes: &AxesView,
    bounds: (i32, i32, i32, i32),
    grid_color: [u8; 4],
    minor_grid_color: [u8; 4],
    frame_color: [u8; 4],
    text_color: [u8; 4],
) {
    let (left, right, top, bottom) = bounds;
    let cx = (left + right) as f32 * 0.5;
    let cy = (top + bottom) as f32 * 0.5;
    let max_r = ((right - left).min(bottom - top) as f32 * 0.5).max(1.0);

    if axes.show_minor_grid {
        for i in 1..30 {
            if i % 5 == 0 {
                continue;
            }
            draw_screen_circle(canvas, cx, cy, max_r * i as f32 / 30.0, minor_grid_color);
        }
    }
    if axes.show_grid {
        for i in 1..=6 {
            draw_screen_circle(canvas, cx, cy, max_r * i as f32 / 6.0, grid_color);
        }
        for i in 0..12 {
            let theta = i as f32 * std::f32::consts::TAU / 12.0;
            let x = cx + theta.cos() * max_r;
            let y = cy - theta.sin() * max_r;
            canvas.draw_line(
                ScreenVertex {
                    x: cx,
                    y: cy,
                    z: 0.0,
                    color: grid_color,
                },
                ScreenVertex {
                    x,
                    y,
                    z: 0.0,
                    color: grid_color,
                },
                1.0,
                0,
                false,
            );
            if i % 3 == 0 {
                let label = format!("{}deg", i * 30);
                draw_text_centered(
                    canvas,
                    (cx + theta.cos() * (max_r + 18.0)) as i32,
                    (cy - theta.sin() * (max_r + 18.0)) as i32,
                    &label,
                    axes.tick_scale,
                    with_alpha(text_color, 0.9),
                );
            }
        }
    }

    if axes.show_box {
        draw_screen_circle(canvas, cx, cy, max_r, frame_color);
    }
}

fn draw_screen_circle(canvas: &mut Canvas, cx: f32, cy: f32, radius: f32, color: [u8; 4]) {
    const SEGMENTS: usize = 96;
    if !radius.is_finite() || radius <= 0.0 {
        return;
    }
    let mut prev = None;
    for i in 0..=SEGMENTS {
        let theta = i as f32 * std::f32::consts::TAU / SEGMENTS as f32;
        let point = ScreenVertex {
            x: cx + theta.cos() * radius,
            y: cy - theta.sin() * radius,
            z: 0.0,
            color,
        };
        if let Some(prev) = prev {
            canvas.draw_line(prev, point, 1.0, 0, false);
        }
        prev = Some(point);
    }
}

fn draw_3d_axes_decorations(canvas: &mut Canvas, axes: &AxesView) {
    let floor_grid_minor = [44, 54, 70, 68];
    let axis_x_color = [235, 80, 80, 230];
    let axis_y_color = [90, 220, 120, 230];
    let axis_z_color = [90, 160, 255, 230];
    let text_color = [212, 220, 234, 255];

    let (bmin, bmax) = axes.bounds_3d;
    let Some(cam) = axes.camera_3d.as_ref() else {
        return;
    };

    let origin_component = |lo: f32, hi: f32| -> f32 {
        if lo <= 0.0 && hi >= 0.0 {
            0.0
        } else {
            lo
        }
    };
    let ox = origin_component(bmin.x, bmax.x);
    let oy = origin_component(bmin.y, bmax.y);
    let oz = origin_component(bmin.z, bmax.z);
    let floor_z = oz;

    if axes.show_minor_grid {
        let divisions = 28usize;
        for i in 0..=divisions {
            if i % 4 == 0 {
                continue;
            }
            let t = i as f32 / divisions as f32;
            let x = bmin.x + t * (bmax.x - bmin.x);
            let y = bmin.y + t * (bmax.y - bmin.y);

            let gx0 = Vec3::new(x, bmin.y, floor_z);
            let gx1 = Vec3::new(x, bmax.y, floor_z);
            let gy0 = Vec3::new(bmin.x, y, floor_z);
            let gy1 = Vec3::new(bmax.x, y, floor_z);

            let Some(a0) = project_3d(gx0, axes.plot_rect, cam, floor_grid_minor) else {
                continue;
            };
            let Some(a1) = project_3d(gx1, axes.plot_rect, cam, floor_grid_minor) else {
                continue;
            };
            canvas.draw_line(a0, a1, 0.9, 0, false);

            let Some(b0) = project_3d(gy0, axes.plot_rect, cam, floor_grid_minor) else {
                continue;
            };
            let Some(b1) = project_3d(gy1, axes.plot_rect, cam, floor_grid_minor) else {
                continue;
            };
            canvas.draw_line(b0, b1, 0.9, 0, false);
        }
    }

    if axes.show_grid {
        let divisions = 7usize;
        let floor_grid_major = [74, 86, 106, 116];
        for i in 0..=divisions {
            let t = i as f32 / divisions as f32;
            let x = bmin.x + t * (bmax.x - bmin.x);
            let y = bmin.y + t * (bmax.y - bmin.y);

            let gx0 = Vec3::new(x, bmin.y, floor_z);
            let gx1 = Vec3::new(x, bmax.y, floor_z);
            let gy0 = Vec3::new(bmin.x, y, floor_z);
            let gy1 = Vec3::new(bmax.x, y, floor_z);

            let Some(a0) = project_3d(gx0, axes.plot_rect, cam, floor_grid_major) else {
                continue;
            };
            let Some(a1) = project_3d(gx1, axes.plot_rect, cam, floor_grid_major) else {
                continue;
            };
            canvas.draw_line(a0, a1, 1.1, 0, false);

            let Some(b0) = project_3d(gy0, axes.plot_rect, cam, floor_grid_major) else {
                continue;
            };
            let Some(b1) = project_3d(gy1, axes.plot_rect, cam, floor_grid_major) else {
                continue;
            };
            canvas.draw_line(b0, b1, 1.1, 0, false);
        }
    }

    let x_end = if bmax.x >= ox {
        Vec3::new(bmax.x, oy, floor_z)
    } else {
        Vec3::new(bmin.x, oy, floor_z)
    };
    let y_end = if bmax.y >= oy {
        Vec3::new(ox, bmax.y, floor_z)
    } else {
        Vec3::new(ox, bmin.y, floor_z)
    };
    let z_end = if bmax.z >= oz {
        Vec3::new(ox, oy, bmax.z)
    } else {
        Vec3::new(ox, oy, bmin.z)
    };
    let origin = Vec3::new(ox, oy, oz);

    if let (Some(o), Some(xp)) = (
        project_3d(origin, axes.plot_rect, cam, axis_x_color),
        project_3d(x_end, axes.plot_rect, cam, axis_x_color),
    ) {
        canvas.draw_line(o, xp, 1.8, 0, false);
        draw_bitmap_text(
            canvas,
            xp.x as i32 + 6,
            xp.y as i32 + 2,
            axes.x_label.as_deref().unwrap_or("x"),
            axes.label_scale,
            axis_x_color,
        );
    }
    if let (Some(o), Some(yp)) = (
        project_3d(origin, axes.plot_rect, cam, axis_y_color),
        project_3d(y_end, axes.plot_rect, cam, axis_y_color),
    ) {
        canvas.draw_line(o, yp, 1.8, 0, false);
        draw_bitmap_text(
            canvas,
            yp.x as i32 + 6,
            yp.y as i32 + 2,
            axes.y_label.as_deref().unwrap_or("y"),
            axes.label_scale,
            axis_y_color,
        );
    }
    if let (Some(o), Some(zp)) = (
        project_3d(origin, axes.plot_rect, cam, axis_z_color),
        project_3d(z_end, axes.plot_rect, cam, axis_z_color),
    ) {
        canvas.draw_line(o, zp, 1.8, 0, false);
        draw_bitmap_text(
            canvas,
            zp.x as i32 + 6,
            zp.y as i32 + 2,
            axes.z_label.as_deref().unwrap_or("z"),
            axes.label_scale,
            axis_z_color,
        );
    }

    if let Some(title) = &axes.title {
        draw_text_centered(
            canvas,
            (axes.viewport.0 + axes.viewport.2 / 2) as i32,
            axes.viewport.1 as i32 + 6,
            title,
            axes.title_scale,
            text_color,
        );
    }
}

fn draw_3d_orientation_gizmo(canvas: &mut Canvas, axes: &AxesView) {
    let Some(cam) = axes.camera_3d.as_ref() else {
        return;
    };
    let forward = (cam.target - cam.position).normalize_or_zero();
    if forward.length_squared() < 1e-9 {
        return;
    }
    let world_up = cam.up.normalize_or_zero();
    let right = forward.cross(world_up).normalize_or_zero();
    if right.length_squared() < 1e-9 {
        return;
    }
    let up = right.cross(forward).normalize_or_zero();
    if up.length_squared() < 1e-9 {
        return;
    }

    #[derive(Clone, Copy)]
    struct AxisItem {
        label: &'static str,
        dir_world: Vec3,
        color: [u8; 4],
        z_sort: f32,
    }

    let mut axis_items = [
        AxisItem {
            label: "X",
            dir_world: Vec3::X,
            color: [235, 80, 80, 255],
            z_sort: 0.0,
        },
        AxisItem {
            label: "Y",
            dir_world: Vec3::Y,
            color: [90, 220, 120, 255],
            z_sort: 0.0,
        },
        AxisItem {
            label: "Z",
            dir_world: Vec3::Z,
            color: [90, 160, 255, 255],
            z_sort: 0.0,
        },
    ];

    for a in &mut axis_items {
        let x = a.dir_world.dot(right);
        let y = a.dir_world.dot(up);
        let z = a.dir_world.dot(-forward);
        a.z_sort = z;
        a.dir_world = Vec3::new(x, y, z);
    }
    axis_items.sort_by(|a, b| a.z_sort.total_cmp(&b.z_sort));

    let scale = ((axes.viewport.2.min(axes.viewport.3) as f32) / 720.0).clamp(0.8, 1.6);
    let gizmo_size =
        ((axes.viewport.2.min(axes.viewport.3) as f32) * 0.16).clamp(44.0, 110.0) * scale;
    let pad = (30.0 * scale).round() as i32;
    let origin = Vec2::new(
        (axes.viewport.0 as i32 + pad) as f32,
        ((axes.viewport.1 + axes.viewport.3) as i32 - pad) as f32,
    );
    canvas.draw_disc(
        origin,
        (2.0 * scale).max(1.0),
        [210, 214, 224, 255],
        0.0,
        false,
    );

    let axis_len = gizmo_size * 0.65;
    let head_len = (8.0 * scale).min(axis_len * 0.35);
    let head_w = 5.0 * scale;
    for a in &axis_items {
        let dir2 = Vec2::new(a.dir_world.x, -a.dir_world.y);
        let mag = dir2.length();
        if !mag.is_finite() || mag < 1e-4 {
            continue;
        }
        let d = dir2 / mag;
        let end = origin + d * axis_len;
        canvas.draw_line(
            ScreenVertex {
                x: origin.x,
                y: origin.y,
                z: 0.0,
                color: a.color,
            },
            ScreenVertex {
                x: end.x,
                y: end.y,
                z: 0.0,
                color: a.color,
            },
            (2.0 * scale).max(1.2),
            0,
            false,
        );

        let base = end - d * head_len;
        let perp = Vec2::new(-d.y, d.x);
        canvas.draw_line(
            ScreenVertex {
                x: end.x,
                y: end.y,
                z: 0.0,
                color: a.color,
            },
            ScreenVertex {
                x: (base + perp * head_w).x,
                y: (base + perp * head_w).y,
                z: 0.0,
                color: a.color,
            },
            (2.0 * scale).max(1.2),
            0,
            false,
        );
        canvas.draw_line(
            ScreenVertex {
                x: end.x,
                y: end.y,
                z: 0.0,
                color: a.color,
            },
            ScreenVertex {
                x: (base - perp * head_w).x,
                y: (base - perp * head_w).y,
                z: 0.0,
                color: a.color,
            },
            (2.0 * scale).max(1.2),
            0,
            false,
        );

        let label_pos = end + d * (10.0 * scale);
        draw_bitmap_text(
            canvas,
            label_pos.x as i32 - 3,
            label_pos.y as i32 - 3,
            a.label,
            1,
            a.color,
        );
    }
}

fn draw_legend_for_axes(canvas: &mut Canvas, figure: &Figure, axes: &AxesView) {
    if !figure.legend_enabled {
        return;
    }
    let entries = figure.legend_entries();
    if entries.is_empty() {
        return;
    }

    let max_entries = entries.len().min(8);
    let pad = 10i32;
    let row_h = 20i32;
    let legend_w = ((axes.viewport.2 as f32 * 0.30).clamp(92.0, 148.0)).round() as i32;
    let legend_h = row_h * max_entries as i32 + 10;
    let x = (axes.viewport.0 + axes.viewport.2) as i32 - legend_w - pad;
    let y = axes.viewport.1 as i32 + 12;

    canvas.fill_rect(x, y, legend_w, legend_h, [8, 14, 24, 220]);
    canvas.stroke_rect(x, y, legend_w, legend_h, [36, 52, 74, 245], 1.0);

    for (i, entry) in entries.into_iter().take(max_entries).enumerate() {
        let yy = y + 6 + i as i32 * row_h + row_h / 2;
        let swatch_x0 = x + 10;
        let swatch_x1 = swatch_x0 + 18;
        let swatch_color = to_u8_rgba(entry.color.to_array());
        canvas.draw_line(
            ScreenVertex {
                x: swatch_x0 as f32,
                y: yy as f32,
                z: 0.0,
                color: swatch_color,
            },
            ScreenVertex {
                x: swatch_x1 as f32,
                y: yy as f32,
                z: 0.0,
                color: swatch_color,
            },
            2.0,
            0,
            false,
        );

        let label = if entry.label.is_empty() {
            "Series".to_string()
        } else {
            entry.label
        };
        draw_bitmap_text(canvas, x + 34, yy - 4, &label, 1, [220, 228, 239, 255]);
    }
}

pub async fn render_figure_rgba_bytes(
    mut figure: Figure,
    width: u32,
    height: u32,
    theme: Option<PlotThemeConfig>,
    camera: Option<&Camera>,
    axes_cameras: Option<&[Camera]>,
    _textmark: Option<&str>,
) -> Result<Vec<u8>, String> {
    let width = width.max(1);
    let height = height.max(1);
    let bg = if is_default_figure_bg(figure.background_color) {
        theme
            .as_ref()
            .map(|cfg| cfg.build_theme().get_background_color())
            .unwrap_or_else(|| Vec4::new(1.0, 1.0, 1.0, 1.0))
    } else {
        figure.background_color
    };
    let mut canvas = Canvas::new(width, height, to_u8_rgba(bg.to_array()));

    let (rows, cols) = figure.axes_grid();
    let viewports = compute_tiled_viewports(width, height, rows.max(1), cols.max(1));
    let axes_count = rows.max(1) * cols.max(1);

    let has_3d_flags: Vec<bool> = (0..axes_count)
        .map(|axes_index| axes_has_3d_content(&figure, axes_index))
        .collect();
    let axes_sizes: Vec<(u32, u32)> = viewports
        .iter()
        .enumerate()
        .map(|(axes_index, vp)| {
            let has_3d = has_3d_flags[axes_index];
            let meta = figure.axes_metadata(axes_index);
            let mut rect = compute_plot_rect(
                *vp,
                has_3d,
                meta.and_then(|m| m.x_tick_label_rotation).unwrap_or(0.0),
                meta.and_then(|m| m.y_tick_label_rotation).unwrap_or(0.0),
            );
            if !has_3d && figure.axes_kind(axes_index) == AxesKind::Polar {
                rect = square_plot_rect(rect);
            }
            (rect.2.max(1), rect.3.max(1))
        })
        .collect();

    let render_items = figure.render_data_with_axes_with_viewport_and_gpu(
        Some((width, height)),
        Some(&axes_sizes),
        None,
        None,
    );

    let mut axes_views = Vec::with_capacity(axes_count);
    for axes_index in 0..axes_count {
        let has_3d = has_3d_flags[axes_index];
        let viewport = viewports[axes_index];
        let meta = figure.axes_metadata(axes_index);
        let mut plot_rect = compute_plot_rect(
            viewport,
            has_3d,
            meta.and_then(|m| m.x_tick_label_rotation).unwrap_or(0.0),
            meta.and_then(|m| m.y_tick_label_rotation).unwrap_or(0.0),
        );
        if !has_3d && figure.axes_kind(axes_index) == AxesKind::Polar {
            plot_rect = square_plot_rect(plot_rect);
        }
        let bounds_2d = choose_axes_bounds(&figure, axes_index, &render_items);
        let (bmin, bmax) = choose_axes_bounds_3d(&figure, axes_index, &render_items, bounds_2d);
        let camera_3d = if has_3d {
            Some(if axes_count == 1 {
                camera.cloned().unwrap_or_else(|| {
                    choose_axes_camera(&figure, axes_index, axes_cameras, bmin, bmax)
                })
            } else {
                choose_axes_camera(&figure, axes_index, axes_cameras, bmin, bmax)
            })
        } else {
            None
        };

        let text = get_axes_title_and_labels(&figure, axes_index);
        let (
            x_ticks,
            y_ticks,
            x_tick_format,
            y_tick_format,
            x_tick_label_rotation,
            y_tick_label_rotation,
        ) = figure
            .axes_metadata(axes_index)
            .map(|meta| {
                (
                    meta.x_ticks.clone(),
                    meta.y_ticks.clone(),
                    meta.x_tick_format.clone(),
                    meta.y_tick_format.clone(),
                    meta.x_tick_label_rotation.unwrap_or(0.0),
                    meta.y_tick_label_rotation.unwrap_or(0.0),
                )
            })
            .unwrap_or((None, None, None, None, 0.0, 0.0));
        let (title_scale, label_scale, tick_scale, show_grid, show_minor_grid, show_box) =
            get_axes_style_and_display_prefs(&figure, axes_index);
        let (colorbar_enabled, colormap) = get_axes_colorbar_prefs(&figure, axes_index);

        axes_views.push(AxesView {
            viewport,
            plot_rect,
            bounds_2d,
            bounds_3d: (bmin, bmax),
            camera_3d,
            has_3d_content: has_3d,
            title: text.title,
            subtitle: text.subtitle,
            x_label: text.x_label,
            y_label: text.y_label,
            z_label: text.z_label,
            x_ticks,
            y_ticks,
            x_tick_format,
            y_tick_format,
            x_tick_label_rotation,
            y_tick_label_rotation,
            title_scale,
            label_scale,
            tick_scale,
            show_grid,
            show_minor_grid,
            show_box,
            axes_kind: figure.axes_kind(axes_index),
            colorbar_enabled,
            colormap,
        });
    }

    for axes in &axes_views {
        if axes.has_3d_content {
            draw_3d_axes_decorations(&mut canvas, axes);
        } else {
            draw_2d_axes_decorations(&mut canvas, axes);
        }
    }

    for (axes_index, rd) in render_items.iter() {
        if rd.vertices.is_empty() {
            continue;
        }
        let Some(axes) = axes_views.get(*axes_index) else {
            continue;
        };
        draw_render_data(&mut canvas, rd, axes);
    }
    for axes in &axes_views {
        if axes.has_3d_content {
            draw_3d_orientation_gizmo(&mut canvas, axes);
            if axes_views.len() == 1 {
                draw_legend_for_axes(&mut canvas, &figure, axes);
            }
        }
        draw_colorbar_for_axes(&mut canvas, axes);
    }

    Ok(canvas.rgba())
}

fn get_axes_colorbar_prefs(figure: &Figure, axes_index: usize) -> (bool, ColorMap) {
    let meta = figure.axes_metadata(axes_index);
    let enabled = figure.colorbar_enabled
        || meta
            .map(|meta| meta.colorbar_enabled)
            .unwrap_or(figure.colorbar_enabled);
    let colormap = meta
        .map(|meta| meta.colormap.clone())
        .unwrap_or_else(|| figure.colormap.clone());
    (enabled, colormap)
}

fn draw_colorbar_for_axes(canvas: &mut Canvas, axes: &AxesView) {
    if !axes.colorbar_enabled {
        return;
    }
    let (_, py, pw, ph) = axes.plot_rect;
    if pw < 48 || ph < 48 {
        return;
    }

    let bar_width = 12_i32;
    let pad = 8_i32;
    let x = (axes.plot_rect.0 + pw) as i32 - bar_width - pad;
    let y = py as i32 + pad;
    let h = ph as i32 - 2 * pad;
    if h <= 0 {
        return;
    }

    for row in 0..h {
        let t = 1.0 - (row as f32 / (h - 1).max(1) as f32);
        let color = axes.colormap.map_value(t);
        let rgba = [
            (color.x.clamp(0.0, 1.0) * 255.0).round() as u8,
            (color.y.clamp(0.0, 1.0) * 255.0).round() as u8,
            (color.z.clamp(0.0, 1.0) * 255.0).round() as u8,
            255,
        ];
        canvas.fill_rect(x, y + row, bar_width, 1, rgba);
    }
    canvas.stroke_rect(x, y, bar_width, h, [50, 58, 72, 255], 1.0);
}

fn draw_render_data(canvas: &mut Canvas, render_data: &RenderData, axes: &AxesView) {
    let width_px = render_data.material.roughness.max(1.0);
    let style_code = render_data.material.metallic as i32;

    match render_data.pipeline_type {
        PipelineType::Lines | PipelineType::LinesNoDepth => {
            let depth_test =
                axes.has_3d_content && render_data.pipeline_type != PipelineType::LinesNoDepth;
            for segment in render_data.vertices.chunks_exact(2) {
                let Some(a) = project_vertex(&segment[0], axes) else {
                    continue;
                };
                let Some(b) = project_vertex(&segment[1], axes) else {
                    continue;
                };
                canvas.draw_line(a, b, width_px, style_code, depth_test);
            }
        }
        PipelineType::Points | PipelineType::Scatter3 => {
            for v in &render_data.vertices {
                let Some(p) = project_vertex(v, axes) else {
                    continue;
                };
                let marker_radius = (v.normal[2].max(1.0) * 0.5).max(1.0);
                canvas.draw_disc(
                    Vec2::new(p.x, p.y),
                    marker_radius,
                    p.color,
                    p.z,
                    axes.has_3d_content,
                );
            }
        }
        PipelineType::Triangles => {
            if axes.has_3d_content && render_data.indices.is_none() {
                return;
            }
            if let Some(indices) = &render_data.indices {
                for tri in indices.chunks_exact(3) {
                    let (Some(v0), Some(v1), Some(v2)) = (
                        render_data.vertices.get(tri[0] as usize),
                        render_data.vertices.get(tri[1] as usize),
                        render_data.vertices.get(tri[2] as usize),
                    ) else {
                        continue;
                    };
                    let (Some(p0), Some(p1), Some(p2)) = (
                        project_vertex(v0, axes),
                        project_vertex(v1, axes),
                        project_vertex(v2, axes),
                    ) else {
                        continue;
                    };
                    canvas.fill_triangle(p0, p1, p2, axes.has_3d_content);
                }
            } else {
                for tri in render_data.vertices.chunks_exact(3) {
                    let (Some(p0), Some(p1), Some(p2)) = (
                        project_vertex(&tri[0], axes),
                        project_vertex(&tri[1], axes),
                        project_vertex(&tri[2], axes),
                    ) else {
                        continue;
                    };
                    canvas.fill_triangle(p0, p1, p2, axes.has_3d_content);
                }
            }
        }
        PipelineType::Textured => {
            if draw_textured_image(canvas, render_data, axes) {
                return;
            }

            if let Some(indices) = &render_data.indices {
                for tri in indices.chunks_exact(3) {
                    let (Some(v0), Some(v1), Some(v2)) = (
                        render_data.vertices.get(tri[0] as usize),
                        render_data.vertices.get(tri[1] as usize),
                        render_data.vertices.get(tri[2] as usize),
                    ) else {
                        continue;
                    };
                    let (Some(p0), Some(p1), Some(p2)) = (
                        project_vertex(v0, axes),
                        project_vertex(v1, axes),
                        project_vertex(v2, axes),
                    ) else {
                        continue;
                    };
                    canvas.fill_triangle(p0, p1, p2, axes.has_3d_content);
                }
            } else {
                for tri in render_data.vertices.chunks_exact(3) {
                    let (Some(p0), Some(p1), Some(p2)) = (
                        project_vertex(&tri[0], axes),
                        project_vertex(&tri[1], axes),
                        project_vertex(&tri[2], axes),
                    ) else {
                        continue;
                    };
                    canvas.fill_triangle(p0, p1, p2, axes.has_3d_content);
                }
            }
        }
    }
}

fn draw_textured_image(canvas: &mut Canvas, render_data: &RenderData, axes: &AxesView) -> bool {
    let Some(ImageData::Rgba8 {
        width,
        height,
        data,
    }) = render_data.image.as_ref()
    else {
        return false;
    };
    if *width == 0 || *height == 0 || data.len() < (*width as usize * *height as usize * 4) {
        return false;
    }

    let projected: Vec<ScreenVertex> = render_data
        .vertices
        .iter()
        .filter_map(|vertex| project_vertex(vertex, axes))
        .collect();
    if projected.is_empty() {
        return false;
    }

    let min_x = projected
        .iter()
        .map(|vertex| vertex.x)
        .fold(f32::INFINITY, f32::min)
        .floor()
        .max(0.0) as i32;
    let max_x = projected
        .iter()
        .map(|vertex| vertex.x)
        .fold(f32::NEG_INFINITY, f32::max)
        .ceil()
        .min(canvas.width as f32 - 1.0) as i32;
    let min_y = projected
        .iter()
        .map(|vertex| vertex.y)
        .fold(f32::INFINITY, f32::min)
        .floor()
        .max(0.0) as i32;
    let max_y = projected
        .iter()
        .map(|vertex| vertex.y)
        .fold(f32::NEG_INFINITY, f32::max)
        .ceil()
        .min(canvas.height as f32 - 1.0) as i32;
    if min_x > max_x || min_y > max_y {
        return false;
    }

    let dst_w = (max_x - min_x).max(1) as f32;
    let dst_h = (max_y - min_y).max(1) as f32;
    let src_w = (*width).saturating_sub(1).max(1) as f32;
    let src_h = (*height).saturating_sub(1).max(1) as f32;
    let depth = projected.iter().map(|vertex| vertex.z).sum::<f32>() / projected.len() as f32;

    for y in min_y..=max_y {
        let v = (y - min_y) as f32 / dst_h;
        let src_y = (v * src_h).round().clamp(0.0, src_h) as usize;
        for x in min_x..=max_x {
            let u = (x - min_x) as f32 / dst_w;
            let src_x = (u * src_w).round().clamp(0.0, src_w) as usize;
            let src = (src_y * *width as usize + src_x) * 4;
            canvas.blend_pixel(
                x,
                y,
                [data[src], data[src + 1], data[src + 2], data[src + 3]],
                depth,
                axes.has_3d_content,
            );
        }
    }

    true
}

pub fn encode_png_bytes(width: u32, height: u32, rgba: &[u8]) -> Result<Vec<u8>, String> {
    use image::{ImageBuffer, ImageFormat, Rgba};

    let image = ImageBuffer::<Rgba<u8>, _>::from_raw(width.max(1), height.max(1), rgba.to_vec())
        .ok_or_else(|| "Failed to create image buffer for CPU PNG encoding".to_string())?;
    let mut out = std::io::Cursor::new(Vec::new());
    image
        .write_to(&mut out, ImageFormat::Png)
        .map_err(|err| format!("Failed to encode CPU PNG bytes: {err}"))?;
    Ok(out.into_inner())
}

pub async fn render_figure_png_bytes(
    figure: Figure,
    width: u32,
    height: u32,
    theme: Option<PlotThemeConfig>,
    camera: Option<&Camera>,
    axes_cameras: Option<&[Camera]>,
    textmark: Option<&str>,
) -> Result<Vec<u8>, String> {
    let rgba =
        render_figure_rgba_bytes(figure, width, height, theme, camera, axes_cameras, textmark)
            .await?;
    encode_png_bytes(width.max(1), height.max(1), &rgba)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::plots::{MeshEdgeMode, MeshFieldLocation, MeshPlot, MeshScalarField};
    use glam::Vec3;
    use std::collections::BTreeSet;

    #[test]
    fn cpu_export_respects_explicit_axes_minor_grid_override() {
        let mut figure = Figure::new();
        figure.minor_grid_enabled = true;
        figure.set_axes_minor_grid_enabled(0, false);

        let (_, _, _, _, show_minor_grid, _) = get_axes_style_and_display_prefs(&figure, 0);
        assert!(!show_minor_grid);

        let mut inherited = Figure::new();
        inherited.minor_grid_enabled = true;
        let (_, _, _, _, inherited_minor_grid, _) = get_axes_style_and_display_prefs(&inherited, 0);
        assert!(inherited_minor_grid);
    }

    #[test]
    fn cpu_export_renders_scalar_mesh_with_colorbar() {
        let mut mesh = MeshPlot::new(
            vec![
                Vec3::new(0.0, 0.0, 0.0),
                Vec3::new(1.0, 0.0, 0.0),
                Vec3::new(0.0, 1.0, 0.0),
                Vec3::new(0.0, 0.0, 1.0),
            ],
            vec![[0, 1, 2], [0, 1, 3], [0, 2, 3], [1, 2, 3]],
        )
        .expect("tetrahedron boundary mesh should be valid");
        mesh.set_edge_mode(MeshEdgeMode::None);
        mesh.set_scalar_field(Some(MeshScalarField::new(
            "structural.von_mises",
            MeshFieldLocation::Triangle,
            vec![0.0, 0.33, 0.66, 1.0],
        )))
        .expect("triangle scalar field should attach");

        let mut figure = Figure::new();
        figure.colorbar_enabled = true;
        figure.add_mesh_plot(mesh);

        let width = 320;
        let height = 240;
        let rgba = pollster::block_on(render_figure_rgba_bytes(
            figure, width, height, None, None, None, None,
        ))
        .expect("CPU render should succeed");

        let background = [255, 255, 255, 255];
        let non_background = rgba
            .chunks_exact(4)
            .filter(|pixel| *pixel != background)
            .count();
        assert!(
            non_background > 2_000,
            "scalar mesh render should not be blank"
        );

        let mut max_vertical_color_variation = 0;
        for x in (width / 2)..(width - 12) {
            let mut colorbar_colors = BTreeSet::new();
            for y in 40..(height - 40) {
                let idx = ((y * width + x) * 4) as usize;
                colorbar_colors.insert([rgba[idx], rgba[idx + 1], rgba[idx + 2], rgba[idx + 3]]);
            }
            max_vertical_color_variation = max_vertical_color_variation.max(colorbar_colors.len());
        }
        assert!(
            max_vertical_color_variation > 12,
            "colorbar strip should contain a visible gradient; saw {max_vertical_color_variation} unique colors"
        );
    }
}