forked from 1b-agent/opencadstudio-upstream
Hakan SevenandClaude Fable 5
e78ad7884d
Every rfd dialog result funnels through sys::handle_path, which now records the picked file's folder (persisted to the config dir), and all pickers are built via sys::file_dialog(), seeded with that folder. Save-As keeps the current tab's own directory as the first choice and falls back to the remembered one. Co-Authored-By: Claude Fable 5 <[email protected]>
819 lines
32 KiB
Rust
819 lines
32 KiB
Rust
// PDF export — converts the paper-space wire model to a PDF file using printpdf.
|
||
//
|
||
// Each WireModel becomes a sequence of DrawLine operations. NaN values in the
|
||
// points array act as segment separators (pen-up).
|
||
//
|
||
// Coordinate system: CAD uses mm units with origin at bottom-left and Y up.
|
||
// printpdf's Point::new(Mm, Mm) also has origin at bottom-left, so no Y-flip
|
||
// is needed — we shift the coordinates by (offset_x, offset_y) to place the
|
||
// drawing origin at the paper origin.
|
||
|
||
use crate::io::plot_style::PlotStyleTable;
|
||
use crate::scene::model::hatch_model::HatchModel;
|
||
#[cfg(not(target_arch = "wasm32"))]
|
||
use crate::scene::model::hatch_model::HatchPattern;
|
||
use crate::scene::WireModel;
|
||
#[cfg(not(target_arch = "wasm32"))]
|
||
use printpdf::{
|
||
Color, Line, LineCapStyle, LineDashPattern, LineJoinStyle, LinePoint, Mm, Op, PaintMode,
|
||
PdfDocument, PdfPage, PdfSaveOptions, Point, Polygon, PolygonRing, Pt, Rgb, WindingOrder,
|
||
};
|
||
#[cfg(not(target_arch = "wasm32"))]
|
||
use std::io::Write;
|
||
use std::path::Path;
|
||
|
||
// The web build has no `printpdf` (it pulls a wasm-incompatible `memchr` via
|
||
// lopdf → nom_locate) and no filesystem, so PDF export is native-only; the web
|
||
// build gets these stubs so the call sites still compile.
|
||
#[cfg(target_arch = "wasm32")]
|
||
pub fn export_pdf(
|
||
_wires: &[WireModel],
|
||
_hatches: &[HatchModel],
|
||
_wipeouts: &[HatchModel],
|
||
_paper_w: f64,
|
||
_paper_h: f64,
|
||
_offset_x: f64,
|
||
_offset_y: f64,
|
||
_rotation_deg: i32,
|
||
_scale: f32,
|
||
_clip: Option<(f32, f32, f32, f32)>,
|
||
_path: &Path,
|
||
_plot_style: Option<&PlotStyleTable>,
|
||
) -> Result<(), String> {
|
||
Err("PDF export is not available in the web version.".into())
|
||
}
|
||
|
||
#[cfg(target_arch = "wasm32")]
|
||
pub async fn pick_pdf_path_owned(_stem: String) -> Option<std::path::PathBuf> {
|
||
None
|
||
}
|
||
|
||
/// mm to PDF points (1 mm = 2.834645 pt).
|
||
const MM_TO_PT: f32 = 2.834645;
|
||
/// `wire.line_weight_px` is the on-screen pixel weight: mm × (96/25.4) × 2.0,
|
||
/// where the ×2 is a screen-legibility boost (see render.rs). Print wants the
|
||
/// true physical weight, so undo both the 96-dpi scaling and the boost before
|
||
/// converting to points — otherwise weights export ~2× too heavy in pixels
|
||
/// (and the old `× 0.35278` left them inconsistent with the physical mm).
|
||
const LW_PX_TO_PT: f32 = MM_TO_PT / ((96.0 / 25.4) * 2.0);
|
||
|
||
// ── Public entry point ────────────────────────────────────────────────────
|
||
|
||
/// Export `wires` to a PDF file.
|
||
///
|
||
/// - `paper_w` / `paper_h`: page dimensions in mm (already swapped for 90°/270° by caller).
|
||
/// - `offset_x` / `offset_y`: added to every wire coordinate so the drawing
|
||
/// origin maps to the bottom-left corner of the page.
|
||
/// - `rotation_deg`: 0 | 90 | 180 | 270 — rotates the entire drawing on the page.
|
||
#[cfg(not(target_arch = "wasm32"))]
|
||
pub fn export_pdf(
|
||
wires: &[WireModel],
|
||
hatches: &[HatchModel],
|
||
wipeouts: &[HatchModel],
|
||
paper_w: f64,
|
||
paper_h: f64,
|
||
offset_x: f64,
|
||
offset_y: f64,
|
||
rotation_deg: i32,
|
||
scale: f32,
|
||
clip: Option<(f32, f32, f32, f32)>,
|
||
path: &Path,
|
||
plot_style: Option<&PlotStyleTable>,
|
||
) -> Result<(), String> {
|
||
let bytes = build_pdf(
|
||
wires,
|
||
hatches,
|
||
wipeouts,
|
||
paper_w as f32,
|
||
paper_h as f32,
|
||
offset_x,
|
||
offset_y,
|
||
rotation_deg,
|
||
scale,
|
||
clip,
|
||
plot_style,
|
||
);
|
||
let mut file = std::fs::File::create(path).map_err(|e| e.to_string())?;
|
||
file.write_all(&bytes).map_err(|e| e.to_string())
|
||
}
|
||
|
||
/// Show a PDF save-file dialog and return the chosen path (or None if cancelled).
|
||
#[cfg(not(target_arch = "wasm32"))]
|
||
pub async fn pick_pdf_path_owned(stem: String) -> Option<std::path::PathBuf> {
|
||
crate::sys::file_dialog()
|
||
.set_title("Export as PDF")
|
||
.set_file_name(&format!("{stem}.pdf"))
|
||
.add_filter("PDF Files", &["pdf"])
|
||
.add_filter("All Files", &["*"])
|
||
.save_file()
|
||
.await
|
||
.map(|h| crate::sys::handle_path(&h))
|
||
}
|
||
|
||
// ── PDF builder ───────────────────────────────────────────────────────────
|
||
|
||
#[cfg(not(target_arch = "wasm32"))]
|
||
fn build_pdf(
|
||
wires: &[WireModel],
|
||
hatches: &[HatchModel],
|
||
wipeouts: &[HatchModel],
|
||
paper_w: f32,
|
||
paper_h: f32,
|
||
// Absolute-world offsets, kept in f64: at UTM the drawing sits at ~5e5/4.5e6
|
||
// where an f32 has ~0.03 m / ~0.5 m of resolution, so an f32 offset is itself
|
||
// already quantised before it can cancel the coordinate it is meant to cancel.
|
||
ox: f64,
|
||
oy: f64,
|
||
rotation_deg: i32,
|
||
scale: f32,
|
||
clip: Option<(f32, f32, f32, f32)>,
|
||
plot_style: Option<&PlotStyleTable>,
|
||
) -> Vec<u8> {
|
||
let mut doc = PdfDocument::new("Open CAD Studio Export");
|
||
let mut ops: Vec<Op> = Vec::new();
|
||
|
||
// White page background.
|
||
ops.push(Op::SetFillColor {
|
||
col: Color::Rgb(Rgb {
|
||
r: 1.0,
|
||
g: 1.0,
|
||
b: 1.0,
|
||
icc_profile: None,
|
||
}),
|
||
});
|
||
ops.push(Op::DrawRectangle {
|
||
rectangle: printpdf::Rect::from_wh(Mm(paper_w).into(), Mm(paper_h).into()),
|
||
});
|
||
|
||
// Round line caps/joins for CAD aesthetics.
|
||
ops.push(Op::SetLineCapStyle {
|
||
cap: LineCapStyle::Round,
|
||
});
|
||
ops.push(Op::SetLineJoinStyle {
|
||
join: LineJoinStyle::Round,
|
||
});
|
||
|
||
// Apply rotation/scale/clip transform if needed.
|
||
// PDF uses mm-based coordinate system with origin at bottom-left.
|
||
// We save state, apply a CTM (+ optional clip path), then restore after drawing.
|
||
let needs_state = rotation_deg != 0 || (scale - 1.0).abs() > 1e-6 || clip.is_some();
|
||
if needs_state {
|
||
let (cos_a, sin_a, tx, ty) = match rotation_deg {
|
||
90 => (0.0_f64, 1.0_f64, 0.0, paper_h as f64),
|
||
180 => (-1.0_f64, 0.0_f64, paper_w as f64, paper_h as f64),
|
||
270 => (0.0_f64, -1.0_f64, paper_w as f64, 0.0),
|
||
_ => (1.0_f64, 0.0_f64, 0.0, 0.0),
|
||
};
|
||
let s = scale as f64;
|
||
// PDF CTM: [a b c d e f] = [cos*s sin*s -sin*s cos*s tx ty]
|
||
ops.push(Op::SaveGraphicsState);
|
||
// Convert mm translation to points (1 mm = 2.834645 pt).
|
||
let tx_pt = (tx * 2.834645) as f32;
|
||
let ty_pt = (ty * 2.834645) as f32;
|
||
ops.push(Op::SetTransformationMatrix {
|
||
matrix: printpdf::CurTransMat::Raw([
|
||
(cos_a * s) as f32,
|
||
(sin_a * s) as f32,
|
||
(-(sin_a) * s) as f32,
|
||
(cos_a * s) as f32,
|
||
tx_pt,
|
||
ty_pt,
|
||
]),
|
||
});
|
||
// Clip rectangle (mm), applied in the pre-scale coordinate space so it
|
||
// matches the wires drawn under the same CTM.
|
||
if let Some((cx, cy, cw, ch)) = clip {
|
||
ops.push(Op::DrawPolygon {
|
||
polygon: Polygon {
|
||
rings: vec![PolygonRing {
|
||
points: vec![
|
||
LinePoint {
|
||
p: Point { x: Pt(cx * MM_TO_PT), y: Pt(cy * MM_TO_PT) },
|
||
bezier: false,
|
||
},
|
||
LinePoint {
|
||
p: Point { x: Pt((cx + cw) * MM_TO_PT), y: Pt(cy * MM_TO_PT) },
|
||
bezier: false,
|
||
},
|
||
LinePoint {
|
||
p: Point {
|
||
x: Pt((cx + cw) * MM_TO_PT),
|
||
y: Pt((cy + ch) * MM_TO_PT),
|
||
},
|
||
bezier: false,
|
||
},
|
||
LinePoint {
|
||
p: Point { x: Pt(cx * MM_TO_PT), y: Pt((cy + ch) * MM_TO_PT) },
|
||
bezier: false,
|
||
},
|
||
],
|
||
}],
|
||
mode: PaintMode::Clip,
|
||
winding_order: WindingOrder::NonZero,
|
||
},
|
||
});
|
||
}
|
||
}
|
||
|
||
|
||
// ── Hatch / wipeout fills (rendered before wires so wires draw on top,
|
||
// matching paper_canvas ordering). Each `emit_hatch` sets its own
|
||
// fill / stroke colour, so the wire pass below starts fresh.
|
||
for hatch in wipeouts.iter().chain(hatches.iter()) {
|
||
emit_hatch(&mut ops, hatch, ox, oy);
|
||
}
|
||
|
||
let mut last_color: Option<[f32; 3]> = None;
|
||
let mut last_lw: Option<f32> = None;
|
||
// Current PDF dash array (empty = solid). Tracked so the dash op is only
|
||
// re-emitted when it actually changes between wires.
|
||
let mut last_dash: Option<Vec<i64>> = None;
|
||
|
||
for wire in wires {
|
||
let [mut r, mut g, mut b, a] = wire.color;
|
||
if a < 0.01 {
|
||
continue;
|
||
}
|
||
// Skip the paper-boundary wire — the white PDF background already provides it.
|
||
if wire.name == "__paper_boundary__" {
|
||
continue;
|
||
}
|
||
// Apply CTB plot style table overrides (color + lineweight).
|
||
let mut lw_override: Option<f32> = None;
|
||
if let Some(ctb) = plot_style {
|
||
if wire.aci > 0 {
|
||
if let Some([cr, cg, cb]) = ctb.resolve_color(wire.aci) {
|
||
r = cr;
|
||
g = cg;
|
||
b = cb;
|
||
}
|
||
lw_override = ctb
|
||
.resolve_lineweight(wire.aci)
|
||
.map(|mm| (mm * MM_TO_PT).max(0.1) / scale.max(1e-6));
|
||
}
|
||
}
|
||
// Near-white and near-yellow (viewport active border) → dark grey for print
|
||
// (only when no CTB override was applied).
|
||
if lw_override.is_none() {
|
||
let is_light = r > 0.80 && g > 0.80 && b > 0.80;
|
||
let is_yellow = r > 0.80 && g > 0.70 && b < 0.30;
|
||
let is_cyan = r < 0.30 && g > 0.70 && b > 0.70;
|
||
if is_light || is_yellow {
|
||
r = 0.0;
|
||
g = 0.0;
|
||
b = 0.0;
|
||
} else if is_cyan {
|
||
// Viewport border: print as dark blue.
|
||
r = 0.0;
|
||
g = 0.15;
|
||
b = 0.50;
|
||
}
|
||
}
|
||
|
||
if last_color
|
||
.map(|c| (c[0] - r).abs() > 0.01 || (c[1] - g).abs() > 0.01 || (c[2] - b).abs() > 0.01)
|
||
.unwrap_or(true)
|
||
{
|
||
ops.push(Op::SetOutlineColor {
|
||
col: Color::Rgb(Rgb {
|
||
r,
|
||
g,
|
||
b,
|
||
icc_profile: None,
|
||
}),
|
||
});
|
||
last_color = Some([r, g, b]);
|
||
}
|
||
|
||
// Line weight: CTB override (in pt) or screen px → points. Divided by
|
||
// `scale` in both branches so pen widths stay absolute under the scaled
|
||
// CTM above — lineweights are independent of plot scale, so without this
|
||
// a Fit plot of a large window renders near-invisible hairlines.
|
||
//
|
||
// A wide polyline is the exception: its band is a geometric width in
|
||
// drawing units, so it must SCALE with the plot (no `/ scale`). Stroke
|
||
// the centre-line at `world_width`, converted mm → pt exactly like the
|
||
// geometry coordinates so the CTM scale renders the band at its true
|
||
// size; the linetype dash pattern below then strokes it dashed. This
|
||
// replaces the model-space hatch band that the shader-band change
|
||
// dropped, and overrides any CTB pen weight (the width is geometry, not
|
||
// a lineweight).
|
||
let lw_pt = if wire.world_width > 0.0 {
|
||
wire.world_width * MM_TO_PT
|
||
} else {
|
||
lw_override
|
||
.unwrap_or_else(|| (wire.line_weight_px * LW_PX_TO_PT).max(0.1) / scale.max(1e-6))
|
||
};
|
||
if last_lw.map(|l| (l - lw_pt).abs() > 0.01).unwrap_or(true) {
|
||
ops.push(Op::SetOutlineThickness { pt: Pt(lw_pt) });
|
||
last_lw = Some(lw_pt);
|
||
}
|
||
|
||
// Linetype dash pattern. Without this every wire exported as a solid
|
||
// line regardless of its linetype (dashed / centre / dash-dot). (#155)
|
||
let dash_arr = dash_array_from_pattern(wire.pattern_length, &wire.pattern, MM_TO_PT);
|
||
if last_dash.as_deref() != Some(dash_arr.as_slice()) {
|
||
let dash = if dash_arr.is_empty() {
|
||
LineDashPattern::default()
|
||
} else {
|
||
LineDashPattern::from_array(&dash_arr, 0)
|
||
};
|
||
ops.push(Op::SetLineDashPattern { dash });
|
||
last_dash = Some(dash_arr);
|
||
}
|
||
|
||
// Emit segments (NaN = pen-up). Points are the "high" half of a
|
||
// double-single pair; fold in the `points_low` residual and cancel the
|
||
// offset in f64 before narrowing. Dropping the residual (or narrowing
|
||
// first) snaps a UTM drawing onto the f32 grid — ~3 cm across, ~50 cm
|
||
// along northing — which is exactly the distortion the plot showed while
|
||
// low-coordinate drawings came out clean. The result is a sheet-mm value
|
||
// in single digits, so f32 is lossless from here.
|
||
let mut segment: Vec<LinePoint> = Vec::new();
|
||
for (pi, &[x, y, _z]) in wire.points.iter().enumerate() {
|
||
if x.is_nan() || y.is_nan() {
|
||
flush_line(&mut ops, &segment);
|
||
segment.clear();
|
||
} else {
|
||
let lo = wire.points_low.get(pi).copied().unwrap_or([0.0; 3]);
|
||
let wx = (x as f64 + lo[0] as f64 + ox) as f32;
|
||
let wy = (y as f64 + lo[1] as f64 + oy) as f32;
|
||
segment.push(LinePoint {
|
||
p: Point::new(Mm(wx), Mm(wy)),
|
||
bezier: false,
|
||
});
|
||
}
|
||
}
|
||
flush_line(&mut ops, &segment);
|
||
}
|
||
|
||
// Text (SDF glyph quads) — re-emitted as vector strokes / fills. Text now
|
||
// renders on-screen only as textured SDF quads (`wire.text_verts`), which
|
||
// this CPU exporter can't sample, so without this pass all text — including
|
||
// dimension text — is missing from the PDF (issue #385). Drawn after the
|
||
// wires (on top) and under the same rotation/scale/clip CTM.
|
||
emit_text(&mut ops, wires, ox, oy, scale, plot_style);
|
||
|
||
if needs_state {
|
||
ops.push(Op::RestoreGraphicsState);
|
||
}
|
||
|
||
let page = PdfPage::new(Mm(paper_w), Mm(paper_h), ops);
|
||
doc.pages.push(page);
|
||
|
||
let mut warnings = Vec::new();
|
||
doc.save(&PdfSaveOptions::default(), &mut warnings)
|
||
}
|
||
|
||
/// Build a PDF dash array (in points) from a WireModel linetype pattern.
|
||
///
|
||
/// `pattern` holds the linetype run lengths in paper-mm: positive = dash,
|
||
/// negative = gap, exactly 0 = a dot, and trailing zeros are padding — so the
|
||
/// real length is the index of the last non-zero element + 1 (same convention
|
||
/// the wire shader uses). Returns an empty vec for a solid line. printpdf's
|
||
/// `LineDashPattern` holds at most six entries, so longer patterns are
|
||
/// truncated to three dash/gap pairs.
|
||
#[cfg(not(target_arch = "wasm32"))]
|
||
fn dash_array_from_pattern(pattern_length: f32, pattern: &[f32; 8], mm_to_pt: f32) -> Vec<i64> {
|
||
if pattern_length <= 1e-6 {
|
||
return Vec::new();
|
||
}
|
||
let count = match pattern.iter().rposition(|&v| v != 0.0) {
|
||
Some(i) => (i + 1).min(6),
|
||
None => return Vec::new(),
|
||
};
|
||
pattern[..count]
|
||
.iter()
|
||
// Round to whole points (printpdf dash entries are integers) and keep a
|
||
// 1 pt floor so a zero-length dot still prints as a short mark.
|
||
.map(|&v| (((v.abs() * mm_to_pt).round()) as i64).max(1))
|
||
.collect()
|
||
}
|
||
|
||
#[cfg(not(target_arch = "wasm32"))]
|
||
fn flush_line(ops: &mut Vec<Op>, pts: &[LinePoint]) {
|
||
if pts.len() < 2 {
|
||
return;
|
||
}
|
||
ops.push(Op::DrawLine {
|
||
line: Line {
|
||
points: pts.to_vec(),
|
||
is_closed: false,
|
||
},
|
||
});
|
||
}
|
||
|
||
/// Emit a single hatch / wipeout as a filled (or stroked, for pattern fills)
|
||
/// polygon. NaN sentinels in `hatch.boundary` split the path into multiple
|
||
/// rings so islands and holes render correctly under the even-odd rule.
|
||
/// Mirrors `scene::paper_canvas::draw_hatch`: solid → fill, pattern → outline,
|
||
/// gradient → solid fill of the averaged colour.
|
||
#[cfg(not(target_arch = "wasm32"))]
|
||
fn emit_hatch(ops: &mut Vec<Op>, hatch: &HatchModel, ox: f64, oy: f64) {
|
||
if hatch.boundary.is_empty() {
|
||
return;
|
||
}
|
||
let [mut r, mut g, mut b, a] = hatch.color;
|
||
if a < 0.01 {
|
||
return;
|
||
}
|
||
// Adapt hatch fills to the white sheet, mirroring the wire pass: colours
|
||
// arrive adapted to the (dark) screen background, so a white/ACI-7 fill
|
||
// would vanish white-on-white on paper. Force near-white/near-yellow → black
|
||
// and near-cyan → dark blue, matching AutoCAD's colour-7-on-white plotting.
|
||
// Genuine colours are untouched; WIPEOUTS keep their paper-white mask.
|
||
if hatch.name != "WIPEOUT_FILL" {
|
||
let is_light = r > 0.80 && g > 0.80 && b > 0.80;
|
||
let is_yellow = r > 0.80 && g > 0.70 && b < 0.30;
|
||
let is_cyan = r < 0.30 && g > 0.70 && b > 0.70;
|
||
if is_light || is_yellow {
|
||
r = 0.0;
|
||
g = 0.0;
|
||
b = 0.0;
|
||
} else if is_cyan {
|
||
r = 0.0;
|
||
g = 0.15;
|
||
b = 0.50;
|
||
}
|
||
}
|
||
// `boundary` holds f32 offsets from the f64 `world_origin`, so resolve the
|
||
// pair in f64 and only narrow once the offset has cancelled — casting
|
||
// `world_origin` to f32 first re-introduces the ~0.5 m UTM quantisation the
|
||
// boundary-relative encoding exists to avoid.
|
||
let (world_ox, world_oy) = (hatch.world_origin[0], hatch.world_origin[1]);
|
||
|
||
// Split the boundary into rings on every NaN-NaN separator.
|
||
let mut rings: Vec<PolygonRing> = Vec::new();
|
||
let mut current: Vec<LinePoint> = Vec::new();
|
||
for &[bx, by] in hatch.boundary.iter() {
|
||
if bx.is_nan() || by.is_nan() {
|
||
if current.len() >= 3 {
|
||
rings.push(PolygonRing { points: std::mem::take(&mut current) });
|
||
} else {
|
||
current.clear();
|
||
}
|
||
continue;
|
||
}
|
||
let px = (bx as f64 + world_ox + ox) as f32;
|
||
let py = (by as f64 + world_oy + oy) as f32;
|
||
current.push(LinePoint {
|
||
p: Point::new(Mm(px), Mm(py)),
|
||
bezier: false,
|
||
});
|
||
}
|
||
if current.len() >= 3 {
|
||
rings.push(PolygonRing { points: current });
|
||
}
|
||
if rings.is_empty() {
|
||
return;
|
||
}
|
||
|
||
let (paint_mode, fill_color) = match &hatch.pattern {
|
||
HatchPattern::Solid => (PaintMode::Fill, [r, g, b]),
|
||
HatchPattern::Pattern(_) => {
|
||
// Pattern fills are emitted as raster line segments below; the
|
||
// outline polygon path itself is skipped because pattern
|
||
// hatches in real DXF do not draw their boundary as part of
|
||
// the fill.
|
||
(PaintMode::Clip, [r, g, b]) // sentinel — handled below
|
||
}
|
||
HatchPattern::Gradient { color2, .. } => {
|
||
// PDF gradients are stored in resource dictionaries; for the
|
||
// fast path we average the two colours, matching paper_canvas.
|
||
let avg = [
|
||
(r + color2[0]) * 0.5,
|
||
(g + color2[1]) * 0.5,
|
||
(b + color2[2]) * 0.5,
|
||
];
|
||
(PaintMode::Fill, avg)
|
||
}
|
||
};
|
||
|
||
// Pattern hatches: rasterise the family lines clipped to the boundary
|
||
// and emit each as a stroked line. Skips the polygon outline entirely.
|
||
if matches!(hatch.pattern, HatchPattern::Pattern(_)) {
|
||
let segments = hatch.pattern_segments();
|
||
if segments.is_empty() {
|
||
return;
|
||
}
|
||
ops.push(Op::SetOutlineColor {
|
||
col: Color::Rgb(Rgb {
|
||
r,
|
||
g,
|
||
b,
|
||
icc_profile: None,
|
||
}),
|
||
});
|
||
for [a, b_pt] in segments {
|
||
// `pattern_segments` returns absolute world f64; cancel the offset
|
||
// before narrowing, as everywhere else in this file.
|
||
let (ax, ay) = ((a[0] + ox) as f32, (a[1] + oy) as f32);
|
||
let (bx, by) = ((b_pt[0] + ox) as f32, (b_pt[1] + oy) as f32);
|
||
ops.push(Op::DrawLine {
|
||
line: Line {
|
||
points: vec![
|
||
LinePoint {
|
||
p: Point::new(Mm(ax), Mm(ay)),
|
||
bezier: false,
|
||
},
|
||
LinePoint {
|
||
p: Point::new(Mm(bx), Mm(by)),
|
||
bezier: false,
|
||
},
|
||
],
|
||
is_closed: false,
|
||
},
|
||
});
|
||
}
|
||
return;
|
||
}
|
||
|
||
// Solid / gradient: filled polygon path.
|
||
if matches!(paint_mode, PaintMode::Fill | PaintMode::FillStroke) {
|
||
ops.push(Op::SetFillColor {
|
||
col: Color::Rgb(Rgb {
|
||
r: fill_color[0],
|
||
g: fill_color[1],
|
||
b: fill_color[2],
|
||
icc_profile: None,
|
||
}),
|
||
});
|
||
}
|
||
ops.push(Op::DrawPolygon {
|
||
polygon: Polygon {
|
||
rings,
|
||
mode: paint_mode,
|
||
winding_order: WindingOrder::EvenOdd,
|
||
},
|
||
});
|
||
}
|
||
|
||
// ── Text (SDF glyph quads → vector strokes / fills) ────────────────────────
|
||
|
||
/// Absolute world XY of a glyph vertex (double-single high + low parts folded).
|
||
///
|
||
/// The fold must happen in f64: the pair exists because the absolute coordinate
|
||
/// does not fit an f32, so `pos + pos_low` evaluated in f32 rounds straight back
|
||
/// to `pos` and throws away the residual it was carrying.
|
||
#[cfg(not(target_arch = "wasm32"))]
|
||
fn glyph_world_xy(v: &crate::scene::pipeline::text_gpu::TextVertex) -> [f64; 2] {
|
||
[
|
||
v.pos[0] as f64 + v.pos_low[0] as f64,
|
||
v.pos[1] as f64 + v.pos_low[1] as f64,
|
||
]
|
||
}
|
||
|
||
/// Adapt a text colour to the white sheet, mirroring the wire/hatch passes:
|
||
/// near-white / near-yellow (colour-7-on-white) → black, near-cyan → dark blue.
|
||
#[cfg(not(target_arch = "wasm32"))]
|
||
fn adapt_text_color([r, g, b]: [f32; 3]) -> [f32; 3] {
|
||
let is_light = r > 0.80 && g > 0.80 && b > 0.80;
|
||
let is_yellow = r > 0.80 && g > 0.70 && b < 0.30;
|
||
let is_cyan = r < 0.30 && g > 0.70 && b > 0.70;
|
||
if is_light || is_yellow {
|
||
[0.0, 0.0, 0.0]
|
||
} else if is_cyan {
|
||
[0.0, 0.15, 0.50]
|
||
} else {
|
||
[r, g, b]
|
||
}
|
||
}
|
||
|
||
/// Re-emit every wire's SDF text as vector geometry.
|
||
///
|
||
/// Each visible glyph rides on `wire.text_verts` as one 6-vertex quad (two
|
||
/// triangles) whose corners are the glyph's atlas `plane` rect run through the
|
||
/// text transform. We recover the glyph's outline / fill from the atlas by the
|
||
/// quad's `uv_min` and map it into that quad by affine interpolation of the
|
||
/// plane rect — so a stroke (LFF) font emits polylines and a filled TrueType
|
||
/// glyph emits filled triangles, exactly where the SDF quad sits.
|
||
#[cfg(not(target_arch = "wasm32"))]
|
||
fn emit_text(
|
||
ops: &mut Vec<Op>,
|
||
wires: &[WireModel],
|
||
ox: f64,
|
||
oy: f64,
|
||
scale: f32,
|
||
plot_style: Option<&PlotStyleTable>,
|
||
) {
|
||
use crate::scene::text::sdf_atlas;
|
||
|
||
if wires.iter().all(|w| w.text_verts.is_empty()) {
|
||
return;
|
||
}
|
||
// Snapshot the atlas' baked-glyph geometry once; drop the lock before use.
|
||
let (table, solid_key) = {
|
||
let Ok(atlas) = sdf_atlas::text_atlas().lock() else {
|
||
return;
|
||
};
|
||
(atlas.export_table(), sdf_atlas::uv_key(atlas.solid_uv()))
|
||
};
|
||
|
||
// `Op::SetLineDashPattern` is persistent graphics state and the wire pass
|
||
// above only re-emits it on change, so whatever the last wire needed is
|
||
// still active here — without this reset a drawing whose last wire carries a
|
||
// HIDDEN/CENTER linetype prints its glyph outlines dashed.
|
||
ops.push(Op::SetLineDashPattern {
|
||
dash: LineDashPattern::default(),
|
||
});
|
||
|
||
for wire in wires {
|
||
let verts = &wire.text_verts;
|
||
if verts.is_empty() {
|
||
continue;
|
||
}
|
||
// Mirror the wire pass: CTB colour/lineweight override by ACI, and the
|
||
// `/ scale` that keeps pen widths absolute under the scaled CTM (a Fit
|
||
// plot would otherwise render text as near-invisible hairlines).
|
||
let mut ctb_color: Option<[f32; 3]> = None;
|
||
let mut lw_override: Option<f32> = None;
|
||
if let Some(ctb) = plot_style {
|
||
if wire.aci > 0 {
|
||
ctb_color = ctb.resolve_color(wire.aci);
|
||
lw_override = ctb
|
||
.resolve_lineweight(wire.aci)
|
||
.map(|mm| (mm * MM_TO_PT).max(0.1) / scale.max(1e-6));
|
||
}
|
||
}
|
||
let lw_pt = lw_override
|
||
.unwrap_or_else(|| (wire.line_weight_px * LW_PX_TO_PT).max(0.1) / scale.max(1e-6));
|
||
|
||
let mut gi = 0;
|
||
while gi + 6 <= verts.len() {
|
||
let quad = &verts[gi..gi + 6];
|
||
gi += 6;
|
||
|
||
let a = quad[0].color[3];
|
||
if a < 0.01 {
|
||
continue;
|
||
}
|
||
// A CTB colour override wins over the white-sheet adaptation, exactly
|
||
// as in the wire pass — else a monochrome.ctb plot plots the lines
|
||
// black and leaves the text on its screen colour.
|
||
let [r, g, b] = ctb_color.unwrap_or_else(|| {
|
||
adapt_text_color([quad[0].color[0], quad[0].color[1], quad[0].color[2]])
|
||
});
|
||
|
||
// Quad corners in world XY: verts run [bl, br, tr, bl, tr, tl].
|
||
let bl = glyph_world_xy(&quad[0]);
|
||
let br = glyph_world_xy(&quad[1]);
|
||
let tr = glyph_world_xy(&quad[2]);
|
||
let tl = glyph_world_xy(&quad[5]);
|
||
// `tl` carries uv = (uv_min.x, uv_min.y) — the atlas tile key.
|
||
let key = sdf_atlas::uv_key([quad[5].uv[0], quad[5].uv[1]]);
|
||
|
||
// Cancel the offset in f64, then narrow: the sheet-mm result is a
|
||
// small number even when the world coordinate is UTM-scale.
|
||
let point = |wx: f64, wy: f64| Point::new(Mm((wx + ox) as f32), Mm((wy + oy) as f32));
|
||
|
||
if let Some(ge) = table.get(&key) {
|
||
// Affine basis of the quad: plane_min → bl, +x → br, +y → tl.
|
||
// The glyph-space maths is small and stays f32; only the lift into
|
||
// world coordinates needs f64.
|
||
let (pmin, pmax) = (ge.plane_min, ge.plane_max);
|
||
let (sx, sy) = (pmax[0] - pmin[0], pmax[1] - pmin[1]);
|
||
if sx.abs() < 1e-9 || sy.abs() < 1e-9 {
|
||
continue;
|
||
}
|
||
let map = |p: [f32; 2]| -> Point {
|
||
let u = ((p[0] - pmin[0]) / sx) as f64;
|
||
let v = ((p[1] - pmin[1]) / sy) as f64;
|
||
let wx = bl[0] + u * (br[0] - bl[0]) + v * (tl[0] - bl[0]);
|
||
let wy = bl[1] + u * (br[1] - bl[1]) + v * (tl[1] - bl[1]);
|
||
point(wx, wy)
|
||
};
|
||
|
||
if !ge.fill_tris.is_empty() {
|
||
// Filled TrueType glyph: one filled triangle per triple.
|
||
ops.push(Op::SetFillColor {
|
||
col: Color::Rgb(Rgb { r, g, b, icc_profile: None }),
|
||
});
|
||
for tri in ge.fill_tris.chunks_exact(3) {
|
||
ops.push(Op::DrawPolygon {
|
||
polygon: Polygon {
|
||
rings: vec![PolygonRing {
|
||
points: tri
|
||
.iter()
|
||
.map(|&p| LinePoint { p: map(p), bezier: false })
|
||
.collect(),
|
||
}],
|
||
mode: PaintMode::Fill,
|
||
winding_order: WindingOrder::NonZero,
|
||
},
|
||
});
|
||
}
|
||
} else {
|
||
// Stroke (LFF pen) font or hollow glyph: polylines. Bold bakes
|
||
// at a 1.7× pen over the same centrelines, so widen to match or
|
||
// a bold run prints at regular weight.
|
||
ops.push(Op::SetOutlineColor {
|
||
col: Color::Rgb(Rgb { r, g, b, icc_profile: None }),
|
||
});
|
||
let pen = if ge.bold { lw_pt * 1.7 } else { lw_pt };
|
||
ops.push(Op::SetOutlineThickness { pt: Pt(pen) });
|
||
for stroke in &ge.strokes {
|
||
if stroke.len() < 2 {
|
||
continue;
|
||
}
|
||
ops.push(Op::DrawLine {
|
||
line: Line {
|
||
points: stroke
|
||
.iter()
|
||
.map(|&p| LinePoint { p: map(p), bezier: false })
|
||
.collect(),
|
||
is_closed: false,
|
||
},
|
||
});
|
||
}
|
||
}
|
||
} else if key == solid_key {
|
||
// Decoration bar (underline / overline / strike): the quad is a
|
||
// solid-texel rectangle — fill it directly from its corners.
|
||
ops.push(Op::SetFillColor {
|
||
col: Color::Rgb(Rgb { r, g, b, icc_profile: None }),
|
||
});
|
||
ops.push(Op::DrawPolygon {
|
||
polygon: Polygon {
|
||
rings: vec![PolygonRing {
|
||
points: [bl, br, tr, tl]
|
||
.iter()
|
||
.map(|&c| LinePoint { p: point(c[0], c[1]), bezier: false })
|
||
.collect(),
|
||
}],
|
||
mode: PaintMode::Fill,
|
||
winding_order: WindingOrder::NonZero,
|
||
},
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#[cfg(all(test, not(target_arch = "wasm32")))]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn clip_and_scale_emit_pdf_bytes() {
|
||
let w = WireModel::solid(
|
||
"test".into(),
|
||
vec![[0.0, 0.0, 0.0], [50.0, 50.0, 0.0]],
|
||
WireModel::WHITE,
|
||
false,
|
||
);
|
||
let bytes = build_pdf(
|
||
&[w],
|
||
&[],
|
||
&[],
|
||
210.0,
|
||
297.0,
|
||
0.0,
|
||
0.0,
|
||
0,
|
||
2.0,
|
||
Some((10.0, 10.0, 100.0, 100.0)),
|
||
None,
|
||
);
|
||
// A valid PDF is produced (starts with the PDF header) and is non-trivial.
|
||
assert!(bytes.starts_with(b"%PDF"), "not a PDF");
|
||
assert!(bytes.len() > 200, "suspiciously small: {}", bytes.len());
|
||
}
|
||
|
||
// Build a WireModel carrying the SDF glyph quads for `text` in the embedded
|
||
// "txt" stroke font, laid out into the process-wide atlas emit_text reads.
|
||
fn text_wire(text: &str, origin: [f64; 3]) -> WireModel {
|
||
use crate::scene::pipeline::text_gpu::push_glyph_vertices;
|
||
use crate::scene::text::{glyph_quads::layout_glyph_quads, sdf_atlas};
|
||
let quads = {
|
||
let mut atlas = sdf_atlas::text_atlas().lock().unwrap();
|
||
layout_glyph_quads(&mut atlas, 10.0, 0.0, 1.0, 0.0, 1.0, "txt", false, text)
|
||
};
|
||
assert!(!quads.is_empty(), "stroke glyphs laid out for {text:?}");
|
||
let mut verts = Vec::new();
|
||
push_glyph_vertices(&mut verts, &quads, origin, 1.0, [1.0, 0.0, 0.0, 1.0], 0.0);
|
||
WireModel {
|
||
text_verts: verts,
|
||
..WireModel::solid("t".into(), Vec::new(), WireModel::WHITE, false)
|
||
}
|
||
}
|
||
|
||
// End-to-end: a page whose only content is SDF text produces a larger PDF
|
||
// than the same page with the text stripped — proving text reaches the file.
|
||
#[test]
|
||
fn text_grows_the_pdf_vs_no_text() {
|
||
let wire = text_wire("HELLO", [20.0, 20.0, 0.0]);
|
||
let mut blank = wire.clone();
|
||
blank.text_verts.clear();
|
||
|
||
let with_text = build_pdf(&[wire], &[], &[], 210.0, 297.0, 0.0, 0.0, 0, 1.0, None, None);
|
||
let no_text = build_pdf(&[blank], &[], &[], 210.0, 297.0, 0.0, 0.0, 0, 1.0, None, None);
|
||
assert!(with_text.starts_with(b"%PDF"));
|
||
assert!(
|
||
with_text.len() > no_text.len(),
|
||
"text did not add content: {} !> {}",
|
||
with_text.len(),
|
||
no_text.len()
|
||
);
|
||
}
|
||
}
|