crates/laymesh-render/src/lib.rs 1//! Shared drawing commands, Skia rasterization, SkPDF and2//! DrawingML exports. The SVG serializer serves file exports and explicit3//! compatibility calls; SVG imports pass through a separate adapter.4#[cfg(target_arch = "wasm32")]5pub use laymesh_core::wasm_allocator::allocation_stats;6pub mod animation;7pub mod display_list;8pub mod display_update;9mod effects;10mod export_geometry;11#[cfg(not(feature = "native"))]12mod gradient_raster;13pub mod surface3d;14#[cfg(not(feature = "native"))]15mod surface_svg;16pub use export_geometry::{export_format, raster_dimensions};17#[cfg(feature = "native")]18pub mod raster;19pub mod retained;20#[cfg(feature = "native")]21mod skia;22mod svg_import;23use base64::Engine;24pub use display_list::{DisplayList, to_display_list};25use laymesh_core::{26 Diagnostic, Loc, Result,27 model::{Scene, escape, jnum, jstr},28};29#[cfg(feature = "native")]30pub use raster::{RasterFrame, render_rgba};31use serde_json::{Value as Json, json};32fn number(n: f64) -> String {33 if n == 0. { "0".into() } else { n.to_string() }34}35fn n(v: &Json, k: &str, d: f64) -> String {36 number(jnum(v, k, d))37}38fn error(message: impl Into<String>) -> Diagnostic {39 Diagnostic::new("E_RENDER", message, "", Loc::default())40}41fn pair(v: &Json, default: [f64; 2]) -> [f64; 2] {42 [43 v[0].as_f64().unwrap_or(default[0]),44 v[1].as_f64().unwrap_or(default[1]),45 ]46}47struct SvgDefs {48 items: Vec<String>,49 dpi: f64,50}51impl std::ops::Deref for SvgDefs {52 type Target = Vec<String>;53 fn deref(&self) -> &Self::Target {54 &self.items55 }56}57impl std::ops::DerefMut for SvgDefs {58 fn deref_mut(&mut self) -> &mut Self::Target {59 &mut self.items60 }61}62fn paint(p: &Json, defs: &mut SvgDefs) -> Result<String> {63 paint_box(p, defs, [1., 1.])64}65fn paint_box(p: &Json, defs: &mut SvgDefs, size: [f64; 2]) -> Result<String> {66 if p["gradient"].is_object() || p["kind"] == "backgroundLayers" || p["kind"] == "conic_gradient"67 {68 let id = format!("paint-{}", defs.len());69 let b = p["paintBox"]70 .as_array()71 .map(|b| {72 [73 b[0].as_f64().unwrap_or(0.),74 b[1].as_f64().unwrap_or(0.),75 b[2].as_f64().unwrap_or(size[0]),76 b[3].as_f64().unwrap_or(size[1]),77 ]78 })79 .unwrap_or([0., 0., size[0], size[1]]);80 let mut source = p.clone();81 source.as_object_mut().unwrap().remove("paintBox");82 let fragment = paint_fragment(&source, [b[2], b[3]], defs.dpi)?;83 let fragment = fragment84 .replace("id='lm", &format!("id='{id}-lm"))85 .replace("url(#lm", &format!("url(#{id}-lm"))86 .replace("href='#lm", &format!("href='#{id}-lm"));87 defs.push(format!("<pattern id='{id}' patternUnits='userSpaceOnUse' width='{}' height='{}' patternTransform='translate({} {})'>{fragment}</pattern>",b[2],b[3],b[0],b[1]));88 return Ok(format!("url(#{id})"));89 }90 let computed = laymesh_core::css_values::gradient_box(p, [0., 0., size[0], size[1]]);91 let p = computed.as_ref();92 if let Some(s) = p.as_str() {93 return Ok(escape(&laymesh_core::color::css(s)));94 }95 if p.is_null() {96 return Ok("none".into());97 }98 let id = format!("paint-{}", defs.len());99 let kind = jstr(p, "kind", "");100 match kind {101 "pattern" | "hatch" => {102 let size = jnum(p, "spacing", 2.).max(0.001);103 let sw = jnum(p, "lineWidth", jnum(p, "line_width", 0.2));104 let color = escape(&laymesh_core::color::css(jstr(p, "color", "#000000")));105 let bg = escape(&laymesh_core::color::css(jstr(p, "background", "none")));106 let mark = if jstr(p, "pattern", jstr(p, "style", "lines")) == "dots" {107 format!(108 "<circle cx='{}' cy='{}' r='{}' fill='{color}'/>",109 size / 2.,110 size / 2.,111 sw / 2.112 )113 } else {114 let mut d = format!(115 "M{} {}L{} {}M0 {}L{} 0M0 {}L{} 0",116 -size,117 size,118 size,119 -size,120 size,121 size,122 size * 2.,123 size * 2.124 );125 if jstr(p, "pattern", jstr(p, "style", "lines")) == "cross" {126 d += &format!(127 "M{} 0L{} {}M0 0L{} {}M0 {}L{} {}",128 -size,129 size,130 2. * size,131 size,132 size,133 -size,134 2. * size,135 size136 );137 }138 format!("<path d='{d}' fill='none' stroke='{color}' stroke-width='{sw}'/>")139 };140 defs.push(format!("<pattern id='{id}' patternUnits='userSpaceOnUse' width='{size}' height='{size}' patternTransform='rotate({})'><rect width='{size}' height='{size}' fill='{bg}'/>{mark}</pattern>",n(p,"angle",0.)));141 }142 "imagePaint" | "image_paint" | "image_fill" => {143 let aspect = if jstr(p, "fit", "contain") == "stretch" {144 "none"145 } else if p["fit"] == "cover" {146 "xMidYMid slice"147 } else {148 "xMidYMid meet"149 };150 let mut pattern = format!(151 "<pattern id='{id}' width='1' height='1' patternContentUnits='objectBoundingBox'><svg width='1' height='1' viewBox='0 0 {} {}' preserveAspectRatio='none'><image width='{}' height='{}' preserveAspectRatio='{aspect}' href='data:{};base64,{}'/></svg></pattern>",152 size[0],153 size[1],154 size[0],155 size[1],156 escape(jstr(p, "mime", "image/png")),157 jstr(p, "data", "")158 );159 if let Some(uri) = p["resourceUri"].as_str() {160 pattern = pattern.replace(161 &format!(162 "data:{};base64,{}",163 jstr(p, "mime", "image/png"),164 jstr(p, "data", "")165 ),166 &escape(uri),167 );168 pattern = pattern.replacen(169 "<image ",170 &format!(171 "<image data-laymesh-asset='{}' ",172 escape(jstr(p, "previewAsset", ""))173 ),174 1,175 );176 }177 defs.push(pattern);178 }179 _ => {180 let stops = p["stops"]181 .as_array()182 .into_iter()183 .flatten()184 .map(|s| {185 let at = s186 .get("at")187 .and_then(Json::as_f64)188 .or_else(|| s[0].as_f64())189 .unwrap_or(0.);190 let color = s191 .get("color")192 .and_then(Json::as_str)193 .or_else(|| s[1].as_str())194 .unwrap_or("#000000");195 let opacity = s196 .get("opacity")197 .and_then(Json::as_f64)198 .or_else(|| s[2].as_f64())199 .unwrap_or(1.);200 format!(201 "<stop offset='{}%' stop-color='{}' stop-opacity='{}'/>",202 number(at * 100.),203 escape(&laymesh_core::color::css(color)),204 number(opacity)205 )206 })207 .collect::<String>();208 if matches!(kind, "linearGradient" | "linear_gradient") {209 let mut a = pair(&p["start"], [0., 0.]);210 let mut b = pair(&p["end"], [1., 1.]);211 if let Some(bb) = p["paintBox"].as_array() {212 let r: Vec<f64> = bb.iter().map(|v| v.as_f64().unwrap_or(0.)).collect();213 a = [r[0] + a[0] * r[2], r[1] + a[1] * r[3]];214 b = [r[0] + b[0] * r[2], r[1] + b[1] * r[3]];215 defs.push(format!("<linearGradient id='{id}' gradientUnits='userSpaceOnUse' x1='{}' y1='{}' x2='{}' y2='{}'>{stops}</linearGradient>",a[0],a[1],b[0],b[1]));216 return Ok(format!("url(#{id})"));217 }218 defs.push(format!("<linearGradient id='{id}' x1='{}%' y1='{}%' x2='{}%' y2='{}%'>{stops}</linearGradient>",a[0]*100.,a[1]*100.,b[0]*100.,b[1]*100.));219 } else {220 let c = pair(&p["center"], [0.5, 0.5]);221 if let Some(b) = p["cssEllipseBox"].as_array() {222 defs.push(format!("<radialGradient id='{id}' gradientUnits='userSpaceOnUse' cx='{}' cy='{}' r='{}' gradientTransform='matrix({} 0 0 {} {} {})'>{stops}</radialGradient>",c[0],c[1],jnum(p,"radius",0.5),b[2],b[3],b[0],b[1]));223 return Ok(format!("url(#{id})"));224 }225 if let Some(bb) = p["paintBox"].as_array() {226 let r: Vec<f64> = bb.iter().map(|v| v.as_f64().unwrap_or(0.)).collect();227 defs.push(format!("<radialGradient id='{id}' gradientUnits='userSpaceOnUse' cx='{}' cy='{}' r='{}'>{stops}</radialGradient>",r[0]+c[0]*r[2],r[1]+c[1]*r[3],jnum(p,"radius",0.5)*r[2].max(r[3])));228 return Ok(format!("url(#{id})"));229 }230 defs.push(format!(231 "<radialGradient id='{id}' cx='{}%' cy='{}%' r='{}%'>{stops}</radialGradient>",232 c[0] * 100.,233 c[1] * 100.,234 jnum(p, "radius", 0.5) * 100.235 ));236 }237 }238 }239 Ok(format!("url(#{id})"))240}241fn paint_fragment(p: &Json, size: [f64; 2], dpi: f64) -> Result<String> {242 let scene = Scene {243 media: Default::default(),244 page_transition: None,245 animation: None,246 schema_version: 8,247 width: size[0].max(1e-12),248 height: size[1].max(1e-12),249 background: p.clone(),250 layout_dpi: 96.,251 canvas_unit: "mm".into(),252 export_dpi: dpi,253 nodes: vec![],254 warnings: vec![],255 speaker_notes: None,256 fonts: Default::default(),257 font_requests: Default::default(),258 };259 let list = to_display_list(&scene)?;260 #[cfg(feature = "native")]261 let svg = portable_svg::render_with_mode(262 &list,263 dpi,264 Some(&mut |node, rect, w, h, _| {265 let mut tile = list.clone();266 tile.nodes = vec![node.clone()];267 let frame = raster::render_region(&tile, rect, w, h)?;268 let image = image::RgbaImage::from_raw(w, h, frame.rgba)269 .ok_or_else(|| error("Invalid paint raster"))?;270 let mut out = std::io::Cursor::new(Vec::new());271 image::DynamicImage::ImageRgba8(image)272 .write_to(&mut out, image::ImageFormat::Png)273 .map_err(|e| error(e.to_string()))?;274 Ok(out.into_inner())275 }),276 false,277 )?;278 #[cfg(not(feature = "native"))]279 let svg = portable_svg::render_with_mode(280 &list,281 dpi,282 Some(&mut |node, rect, w, h, _| gradient_raster::conic(node, rect, w, h)),283 false,284 )?;285 Ok(svg286 .split_once('>')287 .unwrap()288 .1289 .strip_suffix("</svg>")290 .unwrap()291 .into())292}293 294fn wrap(node: &Json, body: String) -> String {295 let (w, h) = (jnum(node, "width", 0.), jnum(node, "height", 0.));296 let (x, y) = (jnum(node, "x", 0.) + w / 2., jnum(node, "y", 0.) + h / 2.);297 format!(298 "<g data-id=\"{}\" opacity=\"{}\" transform=\"translate({} {}) rotate({}) translate({} {})\">{body}</g>",299 escape(jstr(node, "id", "")),300 n(node, "opacity", 1.),301 number(x),302 number(y),303 n(node, "rotation", 0.),304 number(-w / 2.),305 number(-h / 2.)306 )307}308fn item_svg(item: &Json, defs: &mut SvgDefs) -> Result<String> {309 let kind = jstr(item, "kind", "");310 Ok(match kind {311 "glyph" => format!(312 "<text x=\"{}\" y=\"{}\" font-family=\"{}\" font-size=\"{}\" font-weight=\"{}\" font-style=\"{}\" fill=\"{}\" xml:space=\"preserve\">{}</text>",313 n(item, "x", 0.),314 n(item, "baseline", 0.),315 escape(jstr(item, "fontFamily", "")),316 n(item, "fontSize", 3.),317 n(item, "fontWeight", 400.),318 if item["fontItalic"].as_bool().unwrap_or(false) {319 "italic"320 } else {321 "normal"322 },323 escape(&laymesh_core::color::css(jstr(item, "color", "#000000"))),324 escape(jstr(item, "content", ""))325 ),326 "box" => {327 let source = if item["sourceContent"].is_string() {328 format!(329 " data-source-content=\"{}\" data-text-family=\"{}\" data-font-size=\"{}\" data-font-weight=\"{}\" data-font-style=\"{}\" data-baseline=\"{}\"",330 escape(jstr(item, "sourceContent", "")),331 escape(jstr(item, "requestedFamily", "sans-serif")),332 n(item, "fontSize", 3.),333 n(item, "fontWeight", 400.),334 if item["fontItalic"].as_bool().unwrap_or(false) {335 "italic"336 } else {337 "normal"338 },339 n(item, "baseline", 0.)340 )341 } else {342 String::new()343 };344 format!(345 "<rect data-missing-glyph=\"true\"{source} x=\"{}\" y=\"{}\" width=\"{}\" height=\"{}\" fill=\"none\" stroke=\"{}\" stroke-width=\"{}\"/>",346 n(item, "x", 0.),347 n(item, "y", 0.),348 n(item, "width", 2.),349 n(item, "height", 3.),350 escape(&laymesh_core::color::css(jstr(item, "color", "#000000"))),351 n(item, "strokeWidth", 0.15)352 )353 }354 "rule" => {355 if item["dashed"].as_bool().unwrap_or(false) {356 format!(357 "<path d='M{} {}h{}' stroke='{}' stroke-width='{}' stroke-dasharray='{} {}' opacity='{}'/>",358 n(item, "x", 0.),359 n(item, "y", 0.),360 n(item, "width", 0.),361 escape(&laymesh_core::color::css(jstr(item, "color", "#000000"))),362 n(item, "height", 0.1),363 jnum(item, "height", 0.1) * 3.,364 jnum(item, "height", 0.1) * 2.,365 n(item, "opacity", 1.)366 )367 } else {368 format!(369 "<rect x='{}' y='{}' width='{}' height='{}' fill='{}' opacity='{}'/>",370 n(item, "x", 0.),371 n(item, "y", 0.),372 n(item, "width", 0.),373 n(item, "height", 0.),374 escape(&laymesh_core::color::css(jstr(item, "color", "#000000"))),375 n(item, "opacity", 1.)376 )377 }378 }379 "path" if item.get("strokeStyle").is_none() => format!(380 "<path d=\"{}\" fill=\"{}\" stroke=\"{}\" stroke-width=\"{}\" opacity=\"{}\"/>",381 escape(jstr(item, "d", "")),382 paint(&item["fill"], defs)?,383 escape(&laymesh_core::color::css(jstr(item, "stroke", "none"))),384 n(item, "strokeWidth", 0.),385 n(item, "opacity", 1.)386 ),387 "formula" => formula_svg(item, defs)?,388 _ => node_svg(item, defs)?,389 })390}391fn formula_svg(node: &Json, defs: &mut SvgDefs) -> Result<String> {392 let mut body = String::new();393 for item in node["items"].as_array().into_iter().flatten() {394 body += &item_svg(item, defs)?;395 }396 let source = escape(jstr(node, "source", ""));397 Ok(format!(398 "<g transform=\"translate({} {})\" data-latex-source=\"{source}\"><title>{source}</title>{body}</g>",399 n(node, "x", 0.),400 n(node, "y", 0.)401 ))402}403fn stroke_attrs(s: &Json) -> String {404 let dash = s["dash"]405 .as_array()406 .into_iter()407 .flatten()408 .filter_map(Json::as_f64)409 .map(number)410 .collect::<Vec<_>>()411 .join(" ");412 format!(413 "stroke=\"{}\" stroke-width=\"{}\" stroke-opacity=\"{}\" stroke-linecap=\"{}\" stroke-linejoin=\"{}\" stroke-miterlimit=\"{}\"{}",414 escape(&laymesh_core::color::css(jstr(s, "color", "none"))),415 n(s, "width", 0.),416 n(s, "opacity", 1.),417 escape(jstr(s, "cap", "butt")),418 escape(jstr(s, "join", "miter")),419 n(s, "miterLimit", 4.),420 if dash.is_empty() {421 String::new()422 } else {423 format!(424 " stroke-dasharray=\"{dash}\" stroke-dashoffset=\"{}\"",425 n(s, "dashOffset", 0.)426 )427 }428 )429}430fn node_svg(node: &Json, defs: &mut SvgDefs) -> Result<String> {431 node_svg_transformed(node, defs, kurbo::Affine::IDENTITY)432}433fn node_svg_transformed(node: &Json, defs: &mut SvgDefs, parent: kurbo::Affine) -> Result<String> {434 let transform = parent * laymesh_core::geometry::node_transform(node);435 if node["kind"] == "image"436 && node["mime"] == "image/png"437 && node["crop"].is_object()438 && node["_pptxKeepSourceCrop"] != true439 {440 let c = &node["crop"];441 let asset = laymesh_core::assets::crop_raster(442 jstr(node, "data", ""),443 [444 jnum(c, "x", 0.),445 jnum(c, "y", 0.),446 jnum(c, "width", 0.),447 jnum(c, "height", 0.),448 ],449 "",450 Loc::default(),451 )?;452 let mut node = node.clone();453 node["crop"] = Json::Null;454 node["data"] = asset["data"].clone();455 node["intrinsicWidth"] = asset["width"].clone();456 node["intrinsicHeight"] = asset["height"].clone();457 return node_svg_transformed(&node, defs, parent);458 }459 // Clipping contours need the same final physical precision as their ink.460 // A parent group may magnify an already laid out polar plot.461 if node["clipPath"]["geometryRecipe"].is_object() {462 let mut node = node.clone();463 if transform.determinant().abs() > 1e-30 {464 let physical = laymesh_core::geometry::resolved_path(&node["clipPath"], transform);465 node["clipPath"]["d"] = json!((transform.inverse() * physical).to_svg());466 }467 node["clipPath"]468 .as_object_mut()469 .unwrap()470 .remove("geometryRecipe");471 return node_svg_transformed(&node, defs, parent);472 }473 if node["kind"] == "path" && node["geometryRecipe"].is_object() {474 let sx = if jnum(node, "intrinsicWidth", 0.) > 0. {475 jnum(node, "width", 1.) / jnum(node, "intrinsicWidth", 1.)476 } else {477 1.478 };479 let sy = if jnum(node, "intrinsicHeight", 0.) > 0. {480 jnum(node, "height", 1.) / jnum(node, "intrinsicHeight", 1.)481 } else {482 1.483 };484 let final_transform = transform * kurbo::Affine::scale_non_uniform(sx, sy);485 let mut node = node.clone();486 if final_transform.determinant().abs() > 1e-30 {487 let physical = laymesh_core::geometry::resolved_path(&node, final_transform);488 node["d"] = json!((final_transform.inverse() * physical).to_svg());489 }490 node.as_object_mut().unwrap().remove("geometryRecipe");491 return node_svg_transformed(&node, defs, parent);492 }493 if node["kind"] == "path"494 && node["outlineD"].is_null()495 && matches!(496 jstr(&node["strokeStyle"], "compound", "single"),497 "double" | "triple"498 )499 {500 let path = kurbo::BezPath::from_svg(jstr(node, "d", "")).map_err(|_| error("无效路径"))?;501 let mut node = node.clone();502 let sx = if jnum(&node, "intrinsicWidth", 0.) > 0. {503 jnum(&node, "width", 1.) / jnum(&node, "intrinsicWidth", 1.)504 } else {505 1.506 };507 let sy = if jnum(&node, "intrinsicHeight", 0.) > 0. {508 jnum(&node, "height", 1.) / jnum(&node, "intrinsicHeight", 1.)509 } else {510 1.511 };512 let final_transform = transform * kurbo::Affine::scale_non_uniform(sx, sy);513 if final_transform.determinant().abs() > 1e-30 {514 let physical = laymesh_core::geometry::compound_outline_transformed(515 &path,516 &node["strokeStyle"],517 final_transform,518 );519 node["outlineD"] = json!((final_transform.inverse() * physical).to_svg());520 } else {521 node["outlineD"] = json!("");522 }523 return node_svg_transformed(&node, defs, parent);524 }525 let kind = jstr(node, "kind", "");526 let (w, h) = (jnum(node, "width", 0.), jnum(node, "height", 0.));527 let body = match kind {528 "group" => {529 let mut clip = String::new();530 if node["clipPath"].is_object() || node["clip"].is_object() {531 let id = format!("clip-{}", defs.len());532 let c = if node["clipPath"].is_object() {533 format!(534 "<path d=\"{}\" clip-rule=\"{}\"/>",535 escape(jstr(&node["clipPath"], "d", "")),536 escape(jstr(&node["clipPath"], "fillRule", "nonzero"))537 )538 } else {539 let c = &node["clip"];540 format!(541 "<rect x='{}' y='{}' width='{}' height='{}'/>",542 n(c, "x", 0.),543 n(c, "y", 0.),544 n(c, "width", w),545 n(c, "height", h)546 )547 };548 defs.push(format!(549 "<clipPath id='{id}' clipPathUnits='userSpaceOnUse'>{c}</clipPath>"550 ));551 clip = format!(" clip-path='url(#{id})'");552 }553 let sx = if jnum(node, "contentWidth", 0.) > 0. {554 w / jnum(node, "contentWidth", w)555 } else {556 1.557 };558 let sy = if jnum(node, "contentHeight", 0.) > 0. {559 h / jnum(node, "contentHeight", h)560 } else {561 1.562 };563 let mut children = String::new();564 for c in node["children"].as_array().into_iter().flatten() {565 children += &node_svg_transformed(566 c,567 defs,568 transform * kurbo::Affine::scale_non_uniform(sx, sy),569 )?;570 }571 let decorated = if node["effects"].as_array().is_some_and(|e| !e.is_empty()) {572 let mut local = node.clone();573 local["width"] = json!(jnum(node, "contentWidth", w));574 local["height"] = json!(jnum(node, "contentHeight", h));575 effects::apply(&local, format!("<g{clip}>{children}</g>"), defs)576 } else {577 format!("<g{clip}>{children}</g>")578 };579 format!(580 "<g transform='scale({} {})'>{decorated}</g>",581 number(sx),582 number(sy)583 )584 }585 "text" => {586 let mut runs = String::new();587 for r in node["runs"].as_array().into_iter().flatten() {588 runs += &item_svg(r, defs)?;589 }590 if let Some(source) = node["artText"].as_str() {591 format!(592 "<g aria-label=\"{}\"><title>{}</title>{runs}</g>",593 escape(source),594 escape(source)595 )596 } else {597 runs598 }599 }600 "formula" => {601 let mut local = node.clone();602 local["x"] = json!(0);603 local["y"] = json!(0);604 formula_svg(&local, defs)?605 }606 "path" => {607 if node["endpointRecipe"].is_object() {608 let layers = laymesh_core::endpoints::layers(node, transform).map_err(error)?;609 let inverse = transform.inverse();610 let body = layers611 .into_iter()612 .map(|layer| {613 format!(614 "<path d=\"{}\" fill=\"{}\" fill-rule=\"nonzero\" opacity=\"{}\"/>",615 escape(&(inverse * layer.path).to_svg()),616 escape(&layer.color),617 number(layer.opacity)618 )619 })620 .collect::<String>();621 return Ok(wrap(node, effects::apply(node, body, defs)));622 }623 let bounds = kurbo::Shape::bounding_box(624 &kurbo::BezPath::from_svg(jstr(node, "d", "")).unwrap_or_default(),625 );626 let mut source = node["fill"].clone();627 if (source["gradient"].is_object()628 || source["kind"] == "backgroundLayers"629 || source["kind"] == "conic_gradient")630 && source["paintBox"].is_null()631 {632 source["paintBox"] = json!([bounds.x0, bounds.y0, bounds.width(), bounds.height()]);633 }634 let previous_dpi = defs.dpi;635 let local = transform636 * kurbo::Affine::scale_non_uniform(637 w / jnum(node, "intrinsicWidth", w).max(1e-12),638 h / jnum(node, "intrinsicHeight", h).max(1e-12),639 );640 defs.dpi *= portable_svg::max_scale(local);641 let fill = paint_box(&source, defs, [bounds.width(), bounds.height()]);642 defs.dpi = previous_dpi;643 let fill = fill?;644 let attrs = stroke_attrs(&node["strokeStyle"]);645 let d = escape(jstr(node, "d", ""));646 let rule = escape(jstr(node, "fillRule", "nonzero"));647 let sx = if jnum(node, "intrinsicWidth", 0.) > 0. {648 w / jnum(node, "intrinsicWidth", w)649 } else {650 1.651 };652 let sy = if jnum(node, "intrinsicHeight", 0.) > 0. {653 h / jnum(node, "intrinsicHeight", h)654 } else {655 1.656 };657 let path = if let Some(outline) = node["outlineD"].as_str() {658 format!(659 "<path d=\"{d}\" fill=\"{fill}\" fill-rule=\"{rule}\"/><path d=\"{}\" fill=\"{}\" fill-rule=\"evenodd\" fill-opacity=\"{}\"/>",660 escape(outline),661 escape(&laymesh_core::color::css(jstr(662 &node["strokeStyle"],663 "color",664 "#000000"665 ))),666 n(&node["strokeStyle"], "opacity", 1.)667 )668 } else {669 format!("<path d=\"{d}\" fill=\"{fill}\" fill-rule=\"{rule}\" {attrs}/>")670 };671 format!(672 "<g transform='scale({} {})'>{path}</g>",673 number(sx),674 number(sy)675 )676 }677 "rect" => format!(678 "<rect width='{w}' height='{h}' rx='{}' fill='{}' stroke='{}' stroke-width='{}'/>",679 n(node, "radius", 0.),680 paint_box(&node["fill"], defs, [w, h])?,681 escape(&laymesh_core::color::css(jstr(node, "stroke", "none"))),682 n(node, "strokeWidth", 0.)683 ),684 "ellipse" => format!(685 "<ellipse cx='{}' cy='{}' rx='{}' ry='{}' fill='{}' stroke='{}' stroke-width='{}'/>",686 w / 2.,687 h / 2.,688 w / 2.,689 h / 2.,690 paint_box(&node["fill"], defs, [w, h])?,691 escape(&laymesh_core::color::css(jstr(node, "stroke", "none"))),692 n(node, "strokeWidth", 0.)693 ),694 "image" => {695 let iw = jnum(node, "intrinsicWidth", w).max(1e-12);696 let ih = jnum(node, "intrinsicHeight", h).max(1e-12);697 let fit = jstr(node, "fit", "contain");698 let crop = &node["crop"];699 let (cx, cy, cw, ch) = if crop.is_object() {700 (701 jnum(crop, "x", 0.),702 jnum(crop, "y", 0.),703 jnum(crop, "width", iw),704 jnum(crop, "height", ih),705 )706 } else {707 (0., 0., iw, ih)708 };709 let scale = if fit == "cover" {710 (w / cw).max(h / ch)711 } else {712 (w / cw).min(h / ch)713 };714 let (sw, sh) = if fit == "stretch" {715 (w / cw, h / ch)716 } else {717 (scale, scale)718 };719 let (x, y) = ((w - cw * sw) / 2. - cx * sw, (h - ch * sh) / 2. - cy * sh);720 let mut image = format!(721 "<image x='{}' y='{}' width='{}' height='{}' href='data:{};base64,{}' preserveAspectRatio='none'{} />",722 number(x),723 number(y),724 number(iw * sw),725 number(ih * sh),726 escape(jstr(node, "mime", "image/png")),727 jstr(node, "data", ""),728 if jstr(node, "interpolation", "") == "nearest" {729 " image-rendering='optimizeSpeed'"730 } else {731 ""732 }733 );734 if let Some(uri) = node["resourceUri"].as_str() {735 image = image.replace(736 &format!(737 "data:{};base64,{}",738 jstr(node, "mime", "image/png"),739 jstr(node, "data", "")740 ),741 &escape(uri),742 );743 image = image.replacen(744 "<image ",745 &format!(746 "<image data-laymesh-asset='{}' ",747 escape(jstr(node, "previewAsset", ""))748 ),749 1,750 );751 }752 if fit == "cover" || crop.is_object() {753 let id = format!("clip-{}", defs.len());754 defs.push(format!(755 "<clipPath id='{id}'><rect width='{w}' height='{h}'/></clipPath>"756 ));757 format!("<g clip-path='url(#{id})'>{image}</g>")758 } else {759 image760 }761 }762 "points" => {763 let mut out = String::new();764 let positions = node["positions"].as_array().cloned().unwrap_or_default();765 for (i, xy) in positions.chunks_exact(2).enumerate() {766 let x = xy[0].as_f64().unwrap_or(0.);767 let y = xy[1].as_f64().unwrap_or(0.);768 let size = node["markerSizes"][i]769 .as_f64()770 .unwrap_or(jnum(node, "markerSize", 2.));771 // Batched values replace the scalar default: the scalar is the772 // first marker's value, not a second group opacity.773 let alpha =774 node["pointOpacities"][i]775 .as_f64()776 .unwrap_or(jnum(node, "pointOpacity", 1.));777 let fill = node["markerFills"][i].as_str().unwrap_or(jstr(778 node,779 "markerFill",780 jstr(node, "fill", jstr(node, "color", "#000000")),781 ));782 let stroke = jstr(node, "stroke", jstr(node, "markerStroke", "none"));783 let sw = if stroke == "none" {784 0.785 } else {786 jnum(node, "strokeWidth", jnum(node, "markerStrokeWidth", 0.))787 };788 let r = (size - sw).max(0.) / 2.;789 let attrs = format!(790 "fill=\"{}\" stroke=\"{}\" stroke-width=\"{sw}\" opacity=\"{alpha}\" stroke-linejoin=\"round\"",791 escape(fill),792 escape(stroke)793 );794 let marker = jstr(node, "marker", "circle");795 if marker == "circle" {796 out += &format!("<circle cx='{x}' cy='{y}' r='{r}' {attrs}/>");797 } else {798 let pts: Vec<[f64; 2]> = match marker {799 "square" => vec![[-r, -r], [r, -r], [r, r], [-r, r]],800 "diamond" => vec![[0., -r], [r, 0.], [0., r], [-r, 0.]],801 "triangle_down" => vec![[-r, -r], [r, -r], [0., r]],802 "triangle_left" => vec![[r, -r], [r, r], [-r, 0.]],803 "triangle_right" => vec![[-r, -r], [r, 0.], [-r, r]],804 "cross" | "plus" => {805 let t = r / 3.;806 vec![807 [-t, -r],808 [t, -r],809 [t, -t],810 [r, -t],811 [r, t],812 [t, t],813 [t, r],814 [-t, r],815 [-t, t],816 [-r, t],817 [-r, -t],818 [-t, -t],819 ]820 }821 "star" => (0..10)822 .map(|i| {823 let theta = (i as f64 * 36. - 90.).to_radians();824 let rr = if i % 2 == 0 { r } else { r * 0.4 };825 [rr * theta.cos(), rr * theta.sin()]826 })827 .collect(),828 _ => vec![[0., -r], [r, r], [-r, r]],829 };830 let d = pts831 .iter()832 .enumerate()833 .map(|(i, p)| {834 format!(835 "{}{} {}",836 if i == 0 { 'M' } else { 'L' },837 x + p[0],838 y + p[1]839 )840 })841 .collect::<String>();842 out += &format!("<path d='{d}Z' {attrs}/>");843 }844 }845 out846 }847 _ => return Err(error(format!("未知 Scene 对象:{kind}"))),848 };849 Ok(wrap(850 node,851 if kind == "group" {852 body853 } else {854 effects::apply(node, body, defs)855 },856 ))857}858fn used_fonts(scene: &Scene) -> std::collections::BTreeMap<String, (u16, bool)> {859 fn visit(node: &Json, fonts: &mut std::collections::BTreeMap<String, (u16, bool)>) {860 if node["kind"] == "glyph" {861 if let Some(key) = node["fontFamily"].as_str() {862 fonts.insert(863 key.into(),864 (865 jnum(node, "fontWeight", 400.) as u16,866 node["fontItalic"].as_bool().unwrap_or(false),867 ),868 );869 }870 }871 for key in ["children", "runs", "items"] {872 for child in node[key].as_array().into_iter().flatten() {873 visit(child, fonts);874 }875 }876 }877 let mut fonts = std::collections::BTreeMap::new();878 for node in &scene.nodes {879 visit(node, &mut fonts);880 }881 fonts882}883/// Render a portable SVG containing only the user fonts that the scene actually uses.884pub fn render_svg(scene: &Scene) -> Result<String> {885 fn enhanced(n: &Json) -> bool {886 n["threeD"].is_object()887 || n["effects"]888 .as_array()889 .is_some_and(|e| e.iter().any(|e| e["kind"] == "soft_edge"))890 || n["children"]891 .as_array()892 .is_some_and(|c| c.iter().any(enhanced))893 }894 #[cfg(feature = "native")]895 if scene.nodes.iter().any(|n| enhanced(n)) {896 let list = to_display_list(scene)?;897 return portable_svg::render_with_mode(898 &list,899 scene.export_dpi,900 Some(&mut |node, rect, w, h, inner| {901 let mut local = node.clone();902 if let Some(inner) = inner {903 local904 .effects905 .retain(|e| e.soft_edge.is_some() || e.inner == inner);906 local.hint["effectsOnly"] = json!(true);907 }908 let mut tile = list.clone();909 tile.nodes = vec![local];910 let frame = raster::render_region(&tile, rect, w, h)?;911 let image = image::RgbaImage::from_raw(w, h, frame.rgba)912 .ok_or_else(|| error("Invalid object raster"))?;913 let mut png = std::io::Cursor::new(Vec::new());914 image::DynamicImage::ImageRgba8(image)915 .write_to(&mut png, image::ImageFormat::Png)916 .map_err(|e| error(e.to_string()))?;917 Ok(png.into_inner())918 }),919 false,920 );921 }922 #[cfg(not(feature = "native"))]923 if scene.nodes.iter().any(|n| enhanced(n)) {924 return surface_svg::render(to_display_list(scene)?, scene.export_dpi);925 }926 svg(scene, true)927}928fn svg(scene: &Scene, embed_fonts: bool) -> Result<String> {929 if !scene.width.is_finite()930 || !scene.height.is_finite()931 || scene.width <= 0.932 || scene.height <= 0.933 {934 return Err(error("画布尺寸必须为正"));935 }936 let mut defs = SvgDefs {937 items: vec![],938 dpi: scene.export_dpi,939 };940 let mut body = String::new();941 if !scene.background.is_null() && scene.background != "none" {942 body += &format!(943 "<rect width='{}' height='{}' fill='{}'/>",944 number(scene.width),945 number(scene.height),946 paint_box(&scene.background, &mut defs, [scene.width, scene.height])?947 );948 }949 for node in &scene.nodes {950 body += &node_svg(node, &mut defs)?;951 }952 let mut css = String::new();953 if embed_fonts {954 for (key, (weight, italic)) in used_fonts(scene) {955 let Some(font) = scene.fonts.get(&key) else {956 continue;957 };958 let mime = if font.data.starts_with(b"OTTO") {959 "font/otf"960 } else {961 "font/ttf"962 };963 css += &format!(964 "@font-face{{font-family:'{}';font-weight:{weight};font-style:{};src:url(data:{mime};base64,{})}}",965 escape(&key),966 if italic { "italic" } else { "normal" },967 base64::engine::general_purpose::STANDARD.encode(font.data.as_slice())968 );969 }970 }971 Ok(format!(972 "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"{}mm\" height=\"{}mm\" viewBox=\"0 0 {} {}\"><defs><style>{css}</style>{}</defs>{body}</svg>\n",973 number(scene.width),974 number(scene.height),975 number(scene.width),976 number(scene.height),977 defs.join("")978 ))979}980 981#[cfg(feature = "native")]982pub mod config;983#[cfg(any(feature = "native", feature = "portable-export"))]984mod export;985#[cfg(feature = "native")]986mod jpeg_preview;987#[cfg(feature = "native")]988mod native;989#[cfg(feature = "native")]990mod pdf;991pub mod portable_svg;992#[cfg(any(feature = "native", feature = "portable-export"))]993pub mod pptx;994#[cfg(feature = "native")]995pub mod preview_assets;996#[cfg(feature = "native")]997pub mod raster_policy;998#[cfg(feature = "native")]999pub use export::render_export;1000#[cfg(any(feature = "native", feature = "portable-export"))]1001pub use export::{ExportOptions, encode_rgba};1002#[cfg(feature = "native")]1003pub use jpeg_preview::{JpegPreviewOptions, render_jpeg_preview};1004#[cfg(feature = "native")]1005pub use native::{PdfDocument, render_pdf, render_pdf_pages, render_png};1006 1007#[cfg(test)]1008mod tests {1009 use super::*;1010 fn empty() -> Scene {1011 Scene {1012 media: Default::default(),1013 page_transition: None,1014 animation: None,1015 schema_version: 8,1016 width: 25.4,1017 height: 12.7,1018 background: json!("none"),1019 layout_dpi: 96.,1020 canvas_unit: "mm".into(),1021 export_dpi: 300.,1022 nodes: vec![],1023 warnings: vec![],1024 speaker_notes: None,1025 fonts: Default::default(),1026 font_requests: Default::default(),1027 }1028 }1029 #[test]1030 fn physical_svg_dimensions() {1031 let svg = render_svg(&empty()).unwrap();1032 assert!(svg.contains("width=\"25.4mm\""));1033 assert!(!svg.contains("data:font"));1034 }1035 #[test]1036 fn missing_glyph_is_a_font_independent_path() {1037 let mut scene = empty();1038 let mut fs = laymesh_core::text::FontSystem::new(false);1039 scene.nodes.push(1040 laymesh_core::text::layout_text(1041 &json!({"content":"中","font_size":4.}),1042 None,1043 &mut fs,1044 &mut scene.warnings,1045 "test.lay",1046 Loc::default(),1047 )1048 .unwrap()1049 .into(),1050 );1051 let svg = render_svg(&scene).unwrap();1052 assert!(svg.contains("data-missing-glyph"));1053 assert!(!svg.contains("<text "));1054 }1055}