//! Extrude & Bevel, Inflate, Rotate, Extrude & Bevel (Classic) and Rotate (Classic) as live, shaded vector art, //! shared by the canvas and every exporter. Like Revolve, the source path stays editable and the effect draws its 3D faces. use std::sync::Arc; use serde_json::Value; use vectorcraft_doc::color::{BlendMode, Paint}; use vectorcraft_doc::{Appearance, AppearanceItem, Document, Effect, Node, NodeId, NodeKind, OpacityMask}; use vectorcraft_geom::{BezPath, FillRule, PathData, Point, Rect, Vec2}; use vectorcraft_pathops::BoolOp; use vectorcraft_three_d::{ Bevel, BevelShape, DepthPlane, Extrude, Facet, Inflate, MAX_OBJECT_FACES, Mesh, MeshedSolid, PlanarFace, SolidFaces, View, }; #[cfg(test)] use vectorcraft_doc::color::Color; use crate::util::{flag, num, text}; use crate::{GeomContext, apply_geometry_with, is_geometry}; pub(crate) mod classic; pub use classic::{CLASSIC_EXTRUDE, CLASSIC_ROTATE, ROTATE_SURFACES, SHADING_COLORS, classic_extrude_options, classic_shading}; mod source; pub(crate) use source::{resolve, resolve_for}; pub(crate) mod graphics; pub use graphics::{ GRAPHICS, GraphicFrame, MAX_GRAPHICS, MappedGraphic, graphic_symbols, mapped_graphics, missing_symbol, names_graphic_symbol, rename_graphic_symbol, rename_graphic_symbol_in, takes_graphics, with_graphic, }; pub use graphics::{ MAX_OFFSET as GRAPHIC_MAX_OFFSET, NOT_TAKEN as GRAPHICS_NOT_TAKEN, SCALE_RANGE as GRAPHIC_SCALE_RANGE, appearance_graphic_symbols, rename_appearance_graphic_symbol, }; pub(crate) mod shadow; pub(crate) mod wireframe; pub use wireframe::{RENDER, RENDER_MODES, renders_wireframe, three_d_wireframe_in}; pub const EXTRUDE: &str = "threeD.extrude"; pub const INFLATE: &str = "threeD.inflate"; pub const ROTATE: &str = "threeD.rotate"; /// The 3D effects this module draws (Revolve has its own). pub const SOLIDS: [&str; 5] = [EXTRUDE, INFLATE, ROTATE, CLASSIC_EXTRUDE, CLASSIC_ROTATE]; /// Is `id` one of the 3D and Materials effects (Revolve and Revolve (Classic) included)? pub fn is_three_d(id: &str) -> bool { crate::revolve::is_revolve(id) || SOLIDS.contains(&id) } /// Is `id` one of the 3D (Classic) effects: Extrude & Bevel (Classic), Revolve (Classic) or Rotate /// (Classic)? pub fn is_classic_three_d(id: &str) -> bool { id == CLASSIC_EXTRUDE || id == crate::CLASSIC_REVOLVE || id == CLASSIC_ROTATE } /// Does 3D effect `id` turn the art as a flat plane: Rotate or Rotate (Classic)? fn is_plane(id: &str) -> bool { id == ROTATE || id == CLASSIC_ROTATE } /// The 3D and Materials panel's object types and the effect that draws each: (type, effect id). /// Plane keeps the art flat, which is what Rotate draws. pub const THREE_D_TYPES: [(&str, &str); 4] = [("plane", ROTATE), ("extrude", EXTRUDE), ("revolve", crate::REVOLVE), ("inflate", INFLATE)]; /// The parameters of 3D effect `to` for an effect `from` with `params`, as switching the object /// type keeps them: every setting `to` takes keeps its value from `params` (the defaults of `from` /// under them), each rotation angle wrapped into -180° to 180° when `to` is not Revolve, and the /// settings only `to` takes start at their defaults. Settings `to` does not take are dropped. pub fn three_d_params_as(from: &str, params: &Value, to: &str) -> Value { let current = crate::merged_params(from, params); let mut out = crate::default_params(to).and_then(|v| v.as_object().cloned()).unwrap_or_default(); for (key, value) in out.iter_mut() { if let Some(v) = current.get(key) { value.clone_from(v); } } if to != crate::REVOLVE { for key in ["rotationX", "rotationY", "rotationZ"] { if let Some(a) = out.get(key).and_then(Value::as_f64).filter(|a| !(-180.0..=180.0).contains(a)) { out.insert(key.into(), serde_json::json!((a + 180.0).rem_euclid(360.0) - 180.0)); } } } // A plane has only a front, and Revolve's graphics go on its side, named the front, so graphics // on the back cap are dropped. if (to == ROTATE || to == crate::REVOLVE) && let Some(Value::Array(list)) = out.get_mut(GRAPHICS) { list.retain(|g| g.get("face").and_then(Value::as_str) != Some(PlanarFace::Back.id())); } Value::Object(out) } fn solid(fx: &[Effect]) -> Option<(usize, &Effect)> { fx.iter().enumerate().find(|(_, e)| e.visible && SOLIDS.contains(&e.id.as_str())) } /// Does `n` carry a visible Extrude & Bevel, Inflate or Rotate effect? pub fn has_solid(n: &Node) -> bool { solid(&n.appearance.effects).is_some() || n.appearance.items.iter().any(|i| i.visible() && solid(i.effects()).is_some()) } /// The Position presets: (id, [rotation X, Y, Z]). Front, Back, Left, Right, Top and Bottom face /// the art that way; Off-Axis tilts each 20° down and 25° aside (showing the top and right); /// Isometric lays the art on the left, right, top or bottom plane of an isometric view (the /// visible axes foreshortened equally: atan(1/√2) ≈ 35.26° and 45°). Our own values, from the /// geometry of each view. pub const ROTATION_PRESETS: [(&str, [f64; 3]); 16] = [ ("front", [0.0, 0.0, 0.0]), ("back", [0.0, 180.0, 0.0]), ("left", [0.0, 90.0, 0.0]), ("right", [0.0, -90.0, 0.0]), ("top", [-90.0, 0.0, 0.0]), ("bottom", [90.0, 0.0, 0.0]), ("offAxisFront", [-21.88, -23.4, 9.06]), ("offAxisBack", [-158.12, 23.4, -170.94]), ("offAxisLeft", [-40.74, 58.39, -36.26]), ("offAxisRight", [-139.26, -58.39, 143.74]), ("offAxisTop", [-111.88, -23.4, 9.06]), ("offAxisBottom", [68.12, -23.4, 9.06]), ("isometricLeft", [-45.0, -35.26, 30.0]), ("isometricRight", [-45.0, 35.26, -30.0]), ("isometricTop", [45.0, -35.26, 30.0]), ("isometricBottom", [-45.0, -35.26, -30.0]), ]; /// The view parameters every 3D effect shares, named as Revolve's. pub fn view_options(p: &Value) -> View { View { rotation_x: num(p, "rotationX", ROTATION_PRESETS[6].1[0]), rotation_y: num(p, "rotationY", ROTATION_PRESETS[6].1[1]), rotation_z: num(p, "rotationZ", ROTATION_PRESETS[6].1[2]), perspective: num(p, "perspectiveAngle", 0.0), light_rotation: num(p, "lightRotation", vectorcraft_three_d::DEFAULT_LIGHT.0), light_height: num(p, "lightHeight", vectorcraft_three_d::DEFAULT_LIGHT.1), light_behind: flag(p, "lightBehind", false), light_color: crate::lighting::light_color(p), lights: crate::lighting::lights(p), light_intensity: num(p, "lightIntensity", 80.0) / 100.0, light_softness: num(p, "lightSoftness", 0.0) / 100.0, ambient: num(p, "ambient", 25.0) / 100.0, shade: flag(p, "shade", true), } } /// Extrude & Bevel's parameters. `bevel` is `"none"` or a [`BevelShape`] id. pub fn extrude_options(p: &Value) -> Extrude { Extrude { depth: num(p, "depth", 50.0), twist: num(p, "twist", 0.0), taper: num(p, "taper", 100.0) / 100.0, cap: flag(p, "cap", true), bevel: BevelShape::parse(text(p, "bevel", "none")).map(|shape| Bevel { shape, width: num(p, "bevelWidth", 4.0), height: num(p, "bevelHeight", 4.0), repeat: num(p, "bevelRepeat", 1.0).clamp(1.0, 32.0) as usize, space: num(p, "bevelSpace", 0.0) / 100.0, inside: flag(p, "bevelInside", false), both_sides: flag(p, "bevelBothSides", false), }), hidden: false, } } pub fn inflate_options(p: &Value) -> Inflate { Inflate { depth: num(p, "depth", 0.0), volume: num(p, "volume", 50.0), both_sides: flag(p, "bothSides", false), twist: num(p, "twist", 0.0), taper: num(p, "taper", 100.0) / 100.0, cap: flag(p, "cap", true), } } /// The shape a solid is made from: a path's or a compound path's outline. pub(crate) fn profile(n: &Node) -> Option<(PathData, FillRule)> { match &n.kind { NodeKind::Path { path, rule, guide: false, clipping: false, .. } => Some((path.clone(), *rule)), NodeKind::Compound { children, rule } => { Some((PathData::new(children.iter().filter_map(|c| c.path_data()).flat_map(|p| p.subpaths.iter().cloned()).collect()), *rule)) } // Type extrudes as its glyph outlines and stays type: editing it reshapes the solid (#4715). NodeKind::Text(_) => { let mut subpaths = vec![]; crate::outline_text(n)?.walk(&mut |c| subpaths.extend(c.path_data().into_iter().flat_map(|p| p.subpaths.iter().cloned()))); (!subpaths.is_empty()).then(|| (PathData::new(subpaths), FillRule::NonZero)) } _ => None, } } /// What a 3D effect paints `n` with: its own fills and strokes, else, for type that has none, the /// fill and stroke of its first painted run (its characters' colours). pub(crate) fn solid_paints(n: &Node) -> Vec { let own: Vec = n.appearance.items.iter().filter(|i| crate::paints(i)).cloned().collect(); if !own.is_empty() || !matches!(n.kind, NodeKind::Text(_)) { return own; } let mut runs = vec![]; if let Some(outlined) = crate::outline_text(n) { outlined.walk(&mut |c| { if runs.is_empty() && c.path_data().is_some() { runs = c.appearance.items.iter().filter(|i| crate::paints(i)).cloned().collect(); } }); } runs } /// [`solid_paints`] with, for each paint, the item of `n` it copies: the item a live-effect plug-in /// before the paint's own 3D effect is told it sits on. The paints of a type's first run copy no /// item of `n` and have none. pub(crate) fn solid_paint_sources(n: &Node) -> (Vec>, Vec) { let own: Vec<&AppearanceItem> = n.appearance.items.iter().filter(|i| crate::paints(i)).collect(); if own.is_empty() { let paints = solid_paints(n); return (vec![None; paints.len()], paints); } let paints = own.iter().map(|i| (*i).clone()).collect(); (own.into_iter().map(Some).collect(), paints) } fn facets(id: &str, path: &PathData, rule: FillRule, bounds: Rect, p: &Value) -> Result, String> { #[cfg(test)] if !is_plane(id) { SOLID_GEOMETRY_BUILT.with(|n| n.set(n.get() + 1)); } let view = view_options(p); match id { EXTRUDE => vectorcraft_three_d::extrude(path, rule, bounds, extrude_options(p), view), CLASSIC_EXTRUDE => vectorcraft_three_d::extrude(path, rule, bounds, classic_extrude_options(p), view), INFLATE => vectorcraft_three_d::inflate(path, rule, bounds, inflate_options(p), view), _ => vectorcraft_three_d::plane(path, rule, bounds, view), } } /// [`facets`], and with `cast` for Extrude & Bevel or Rotate the faces the solid's shadow is cast /// from, from the same build. Inflate's solids are built together ([`built_solids_cast`]), and the /// classic effects cast no shadow: they keep no faces. fn facets_and_faces( id: &str, path: &PathData, rule: FillRule, bounds: Rect, p: &Value, cast: bool, ) -> Result<(Vec, Option), String> { let view = view_options(p); #[cfg(test)] if cast && id == EXTRUDE { SOLID_GEOMETRY_BUILT.with(|n| n.set(n.get() + 1)); } let built = match id { EXTRUDE if cast => vectorcraft_three_d::extrude_shadowed(path, rule, bounds, extrude_options(p), view), ROTATE if cast => vectorcraft_three_d::plane_shadowed(path, rule, bounds, view), _ => return facets(id, path, rule, bounds, p).map(|f| (f, None)), }; built.map(|(f, faces)| (f, Some(faces))) } /// Check solid `id`'s parameter values `p` alone: the part of [`validate_solid`] that does not /// need the object. fn validate_solid_params(id: &str, p: &Value) -> Result<(), String> { if id == CLASSIC_EXTRUDE { classic::validate(p)?; } if id == CLASSIC_ROTATE { classic::validate_rotate(p)?; } crate::lighting::validate(p)?; shadow::validate(p)?; graphics::validate(id, p)?; wireframe::validate_render(id, p)?; if let Some(v) = p.get("bevel") && !v.as_str().is_some_and(|s| s == "none" || BevelShape::parse(s).is_some()) { let names: Vec<_> = BevelShape::ALL.iter().map(|b| b.id()).collect(); return Err(format!("bevel must be none or one of {}", names.join(", "))); } Ok(()) } /// The name an error gives 3D effect `id`. pub(crate) fn label_of(id: &str) -> &'static str { crate::effect_info(id).map_or("This effect", |e| e.label.trim_end_matches('…')) } /// Validate before a command changes the document; the evaluator bounds loaded files too. pub fn validate_solid(n: &Node, id: &str, p: &Value) -> Result<(), String> { validate_solid_in(None, n, id, p) } /// [`validate_solid`] with the symbols of `doc`: a symbol instance, a blend and a clipping group /// build from the art they show ([`resolve`]). pub fn validate_solid_in(doc: Option<&Document>, n: &Node, id: &str, p: &Value) -> Result<(), String> { validate_solid_for(doc, n, id, p, (None, None)) } /// [`validate_solid_in`] for the effect at `(item, index)`: index `index` of the effects of the /// object (`item` `None`) or of its appearance item `item`, whose shadow is cast by that item's /// solid alone. The index is the effects' length for a new effect. The solids are checked as /// [`solid_art_in`] draws them: from the shapes after the geometry effects before the 3D effect. /// On the object (or group) with `index` `None`, that effect is its first visible Extrude & Bevel, /// Inflate or Rotate, as drawn, or a new one after its other effects when it has none. fn validate_solid_for(doc: Option<&Document>, n: &Node, id: &str, p: &Value, at: (Option, Option)) -> Result<(), String> { validate_solid_params(id, p)?; if let Some(doc) = doc { graphics::validate_symbols(doc, p)?; } let label = label_of(id); let n = &*source::resolve_for(doc, n, label, is_plane(id))?; let effects = &n.appearance.effects; let index = match at { (None, Some(index)) => index, _ => solid(effects).map_or(effects.len(), |(index, _)| index), }; let before = effects.get(..index).unwrap_or(effects); if is_container(n) { let mut shapes = members(n, label)?; reshape_members(n, before, &mut shapes); let b = union_bounds(&shapes).ok_or_else(|| format!("{label} requires a group holding a shape with at least two anchors"))?; check_profiles(id, p, &shapes, b)?; check_solids(id, p, &shapes)?; return check_cast(id, p, &shapes); } let (path, rule) = object_profile(n, label)?; let anchors = || format!("{label} requires a shape with at least two anchors"); path.bounds().ok_or_else(anchors)?; let ctx = GeomContext::of(n); // With its shadow on, the shadow of the object's solids (or of the item's) must fit too. let (path, items) = match at.0.and_then(|i| Some((n.appearance.items.get(i)?, at.1.unwrap_or(usize::MAX)))) { Some((item, index)) => { let path = geometry(&path, effects, &ctx); (geometry(&path, item.effects().get(..index).unwrap_or(item.effects()), &ctx.item(item)), vec![item.clone()]) } None => (geometry(&path, before, &ctx), solid_paints(n)), }; let b = path.bounds().ok_or_else(anchors)?; let shapes = [Profile { path, rule, items, opacity: 1.0, scopes: vec![] }]; check_profiles(id, p, &shapes, b)?; check_solids(id, p, &shapes)?; check_cast(id, p, &shapes) } /// With the shadow of 3D effect `id` with parameters `p` on, an error when the shadow of `shapes` /// is past the limits ([`cast_shadow`]). In wireframe mode no shadow is drawn, and none is checked. fn check_cast(id: &str, p: &Value, shapes: &[Profile]) -> Result<(), String> { if wireframe::wireframe_params(id, p) { return Ok(()); } cast_shadow(id, p, shapes).map(|_| ()) } /// Do the solids 3D effect `id` with parameters `p` builds from the profiles of `shapes` about `b` /// build? Only the profiles no solid of [`check_solids`] is built from are built here: every /// shape's for Rotate, and for Extrude & Bevel and Inflate the profile of a shape with no fill, /// whose solids are its strokes' outlines or none. A filled shape's profile is its fill's solid, /// which [`check_solids`] builds once, about the bounds the effect draws it about. fn check_profiles(id: &str, p: &Value, shapes: &[Profile], b: Rect) -> Result<(), String> { shapes .iter() .filter(|s| is_plane(id) || !s.items.iter().any(|i| matches!(i, AppearanceItem::Fill(_)))) .try_for_each(|s| facets(id, &s.path, s.rule, b, p).map(|_| ())) } /// Do the solids 3D effect `id` with parameters `p` builds from the fills and strokes of `shapes` /// fit, each on its own and all of them together ([`built_solids`])? Rotate's planes are not /// counted. fn check_solids(id: &str, p: &Value, shapes: &[Profile]) -> Result<(), String> { let Some(b) = union_bounds(shapes).filter(|_| !is_plane(id)) else { return Ok(()) }; let (parts, bounds) = solid_parts(shapes, b); built_solids(id, p, &parts, bounds, MAX_OBJECT_FACES).try_for_each(|r| r.map(|_| ())) } /// [`profile`], or the error a command reports for object `n`: type with no outlines to build from /// (empty, or only spaces) is a shape without anchors, an image is traced first, and any other /// object is the wrong kind. pub(crate) fn object_profile(n: &Node, label: &str) -> Result<(PathData, FillRule), String> { profile(n).ok_or_else(|| match n.kind { NodeKind::Text(_) => format!("{label} requires a shape with at least two anchors"), NodeKind::Image(_) => source::image_refusal(label), _ => format!("{label} currently requires a path, compound path, type, group, blend or symbol instance. Expand other objects first."), }) } /// A group in a 3D effect's group, or a member of it, whose opacity is below 100%, whose blending /// mode is not Normal or that has an opacity mask. The members of one group share its `key`. #[derive(Clone, Debug, PartialEq)] pub(crate) struct Scope { pub(crate) key: usize, pub(crate) opacity: f32, pub(crate) blend: BlendMode, /// The object's opacity mask, unless it has none or it is disabled. The mask art is in /// document coordinates, as the solids' faces are. pub(crate) mask: Option>, } impl Scope { /// The scope of `n` with key `key`, or `None` when `n` is opaque, blends normally and has no /// opacity mask that applies. fn of(n: &Node, key: usize) -> Option { let mask = n.extras().mask.as_deref().filter(|m| !m.disabled); (n.opacity < 1.0 || n.blend != BlendMode::Normal || mask.is_some()).then(|| Scope { key, opacity: n.opacity, blend: n.blend, mask: mask.map(|m| Arc::new(m.clone())), }) } /// A group of `children` with id `id` and this scope's opacity, blending mode and opacity mask. pub(crate) fn group(&self, id: NodeId, children: Vec>) -> Node { let mut group = Node::group(id, children); group.opacity = self.opacity; group.blend = self.blend; if let Some(mask) = &self.mask { group.extras_mut().mask = Some(Box::new((**mask).clone())); } group } } /// Does `scope` draw its members' faces other than plainly: does it have an opacity mask or a /// blending mode other than Normal? fn composites(scope: &Scope) -> bool { scope.mask.is_some() || scope.blend != BlendMode::Normal } /// `surfaces`, each with the scopes of the member it was built from, in groups with the opacity /// masks and blending modes of those scopes, so each applies to the faces of the members it holds. /// The members' opacity is already in their paint ([`Profile::opacity`]), so these groups are /// opaque. fn masked(id: NodeId, surfaces: Vec<(&[Scope], Arc)>) -> Vec> { let masks: Vec<(Vec, Arc)> = surfaces .into_iter() .map(|(scopes, s)| { let masks = scopes.iter().filter(|s| composites(s)).map(|s| Scope { opacity: 1.0, ..s.clone() }).collect(); (masks, s) }) .collect(); crate::revolve::scoped(id, masks.iter().map(|(scopes, s)| (scopes.as_slice(), s.clone())).collect(), 0) } /// Does any of `shapes` sit in a scope with an opacity mask or a blending mode other than Normal? pub(crate) fn has_masks(shapes: &[Profile]) -> bool { shapes.iter().any(|s| s.scopes.iter().any(composites)) } /// One shape a solid is built from: its outline and fill rule, the fills and strokes that paint /// it, and the opacity of the objects it is in multiplied together (1 for the object with the /// effect itself). `scopes` lists those objects with transparency or an opacity mask of their own /// ([`Scope`]), from the outermost group down to the member itself (none for the object itself). /// Group Revolve applies each once, to the surfaces of the members it holds together; the other 3D /// effects apply each opacity mask that way. pub(crate) struct Profile { pub(crate) path: PathData, pub(crate) rule: FillRule, pub(crate) items: Vec, pub(crate) opacity: f32, pub(crate) scopes: Vec, } /// Is `n` a group or layer (a 3D effect on it turns its members about one shared axis)? pub(crate) fn is_container(n: &Node) -> bool { matches!(n.kind, NodeKind::Group { clip: false, .. } | NodeKind::Layer { .. }) } /// The bounds of every shape together: the centre a group's members turn about. pub(crate) fn union_bounds(shapes: &[Profile]) -> Option { shapes.iter().filter_map(|s| s.path.bounds()).reduce(|a, c| a.union(c)) } /// The most members a 3D effect on a group builds solids from. const MAX_MEMBERS: usize = 4096; /// The most triangles the meshes of one 3D effect hold together (about 290 MB of corners and /// normals): past it the object is too complex to export. const MAX_MESH_TRIANGLES: usize = 2_000_000; /// The most facets of solid colors under colored lights that one 3D effect draws as faces of their /// own, to go in one order with other solids' faces. Each such face is about 16 nodes, a composite /// of a whole surface about 6 per facet, so at this count the faces hold about as many nodes as the /// composites do at the paint-copy allowance. Past it those solids draw as one composite each. const MAX_FACE_COMPOSITES: usize = 30_720; /// The shapes a 3D effect on group or layer `n` builds its solids from: every visible path, /// compound path and type in it (after [`resolve`] gives it the art of its symbol instances, blends /// and clipping groups), at any depth of its groups, each through its own geometry /// effects, then those of each group it is in (on that group's members together), and painted /// with its own fills and strokes. Like the effect on a group in the /// reference app, they turn about one shared axis (the centre of their bounds together) rather /// than each about its own. An error names what the group holds that can't become a solid. pub(crate) fn members(n: &Node, label: &str) -> Result, String> { struct Walk<'a> { label: &'a str, out: Vec, keys: usize, } fn walk(n: &Node, opacity: f32, scopes: &[Scope], w: &mut Walk) -> Result<(), String> { let label = w.label; for c in n.children().into_iter().flatten() { if !c.visible || c.is_guide() { continue; } let opacity = opacity * c.opacity; let mut scopes = scopes.to_vec(); if let Some(scope) = Scope::of(c, w.keys + 1) { w.keys += 1; scopes.push(scope); } if is_container(c) { let first = w.out.len(); walk(c, opacity, &scopes, w)?; // The group's own geometry effects reshape its members together, as it is drawn. if let Some(shapes) = w.out.get_mut(first..) { reshape_members(c, &c.appearance.effects, shapes); } continue; } let Some((path, rule)) = profile(c) else { let what = match &c.kind { NodeKind::Image(_) => return Err(source::image_refusal(label)), NodeKind::Path { clipping: true, .. } => "clipping paths", _ => "other objects", }; return Err(format!( "{label} on a group needs paths, compound paths, type, groups, clipping groups, blends and symbol instances: release or expand its {what} first." )); }; if w.out.len() >= MAX_MEMBERS { return Err(format!("{label} on a group takes at most {MAX_MEMBERS} objects")); } let path = geometry(&path, &c.appearance.effects, &GeomContext::of(c)); if path.bounds().is_some() { w.out.push(Profile { path, rule, items: solid_paints(c), opacity, scopes }); } } Ok(()) } let mut w = Walk { label, out: vec![], keys: 0 }; walk(n, 1.0, &[], &mut w)?; Ok(w.out) } /// Can 3D effect `id` (Revolve included, [`is_three_d`]) with parameters `p` draw `n`? Checked /// before a command changes the document: Revolve by [`crate::validate_revolve`], the others by /// [`validate_solid`]. pub fn validate_three_d(n: &Node, id: &str, p: &Value) -> Result<(), String> { validate_three_d_in(None, n, id, p) } /// [`validate_three_d`] with the symbols of `doc` ([`validate_solid_in`]). pub fn validate_three_d_in(doc: Option<&Document>, n: &Node, id: &str, p: &Value) -> Result<(), String> { graphics::validate(id, p)?; if crate::revolve::is_revolve(id) { crate::revolve::validate_in(doc, n, id, p) } else { validate_solid_in(doc, n, id, p) } } /// [`validate_three_d`] for an effect at `(item, index)`: index `index` of the effects of /// appearance item `item` of `n`, or of the object itself when `item` is `None` (the effects' /// length for a new effect). An Extrude & Bevel, Inflate or Rotate is checked on the shapes after /// the geometry effects before that index. A Revolve on a fill or stroke is checked in that item's /// paint, after the item's geometry effects before it, together with the object's other items that /// carry a Revolve. A group's or layer's fills and strokes take no 3D effect: only the group's own /// effect draws. pub fn validate_three_d_at(n: &Node, id: &str, p: &Value, at: (Option, usize)) -> Result<(), String> { validate_three_d_at_in(None, n, id, p, at) } /// [`validate_three_d_at`] with the symbols of `doc` ([`validate_solid_in`]). A symbol instance, a /// blend and a clipping group take a 3D effect as groups do: on the object itself. pub fn validate_three_d_at_in(doc: Option<&Document>, n: &Node, id: &str, p: &Value, at: (Option, usize)) -> Result<(), String> { graphics::validate(id, p)?; match at { (Some(_), _) if is_container(n) || source::resolves(n) => { Err("A 3D effect on a group or layer goes on the group itself, not on its fill or stroke".into()) } (Some(item), index) if crate::revolve::is_revolve(id) => crate::revolve::validate_item_of(doc, n, id, p, item, index), (None, _) if crate::revolve::is_revolve(id) => crate::revolve::validate_in(doc, n, id, p), (item, index) => validate_solid_for(doc, n, id, p, (item, Some(index))), } } /// Are 3D effect `id`'s parameter values `p` valid? The checks of [`validate_three_d`] that do not /// build the art, for an edit that hides the effect: hidden, it draws nothing, so its object does /// not need to fit. pub fn validate_three_d_params(id: &str, p: &Value) -> Result<(), String> { graphics::validate(id, p)?; if crate::revolve::is_revolve(id) { crate::revolve::validate_params_of(id, p) } else { validate_solid_params(id, p) } } /// One surface: each facet a path shaded from `paint`, as a group with the paint's opacity and /// blend mode (so overlapping facets don't add up their transparency). Under colored lights a solid /// color with smooth facets is one composite of all its facets ([`composites_facets`]) unless /// `faces`: then each facet is a face of its own, as in a gradient, so the faces can go in one order /// with the faces of other solids. fn surface(n: &Node, facets: Vec, paint: &Paint, opacity: f32, blend: BlendMode, colored: bool, faces: bool) -> Node { if !faces && composites_facets(&facets, paint, colored) { let mut group = crate::lighting::solid_surface(n.id, &facets, paint); group.opacity = opacity; group.blend = blend; return group; } // Preserve existing white-light paints and alpha composition exactly. let (opaque, mask) = if colored { crate::lighting::opaque_paint(paint) } else { (paint.clone(), None) }; let paint = &opaque; let children = facets .into_iter() .map(|face| { // Adjacent facets, antialiased on their own, would leave hairline seams: a narrow // stroke of the same paint closes them ([`seam_width`]). let seam = seam_width(&face); if let Some(g) = face.rgb_gradient && (paint.color().is_some() || matches!(paint, Paint::Gradient(_))) { return Arc::new(crate::lighting::facet_art(n.id, &face.path(), paint, g, seam)); } let items = crate::lighting::fills(paint, face.illumination, face.brightness, colored); let items = items .into_iter() .flat_map(|item| { let AppearanceItem::Fill(fill) = &item else { return vec![item] }; let mut edge = crate::lighting::seam_stroke(fill.paint.clone(), seam); edge.opacity = fill.opacity; vec![item, AppearanceItem::Stroke(edge)] }) .collect(); Arc::new(Node::path(n.id, face.path(), Appearance { items, ..Default::default() })) }) .collect(); let mut group = Node::group(n.id, children); group.opacity = opacity; group.blend = blend; if let Some(mask) = mask { let bounds = group.visual_bounds().unwrap_or(Rect::ZERO).inflate(1.0, 1.0); let coverage = Node::path(n.id, vectorcraft_geom::shapes::rectangle(bounds), Appearance::basic(mask, Paint::None, 0.0)); group.extras_mut().mask = Some(Box::new(vectorcraft_doc::OpacityMask::new(coverage, true))); } group } /// The width of the stroke of a facet's own paint that closes the seams between `face` and its /// neighbors. No wider than the facet is thick: seen at a grazing angle a facet can be thinner than /// the stroke, and its stroke would then paint over its neighbors. pub(crate) fn seam_width(face: &Facet) -> f64 { (face.thickness() / 2.0).clamp(0.05, 0.75) } /// Is a surface of `facets` in `paint` one composite of all its facets when [`surface`] draws it /// whole: a solid color under colored lights with smooth shading? fn composites_facets(facets: &[Facet], paint: &Paint, colored: bool) -> bool { colored && paint.color().is_some() && facets.iter().any(|face| face.rgb_gradient.is_some()) } /// `item`'s paint, its opacity times `member` (the opacity of the objects it is in) and its blend. fn paint_of(item: &AppearanceItem, member: f32) -> (Paint, f32, BlendMode) { match item { AppearanceItem::Fill(f) => (f.paint.clone(), f.opacity * member, f.blend), AppearanceItem::Stroke(s) => (s.paint.clone(), s.opacity * member, s.blend), } } /// `item`'s paint, borrowed (for checks that must not copy it). fn paint_ref(item: &AppearanceItem) -> &Paint { match item { AppearanceItem::Fill(f) => &f.paint, AppearanceItem::Stroke(s) => &s.paint, } } /// Are `facets` drawn over an underlay of themselves ([`crate::lighting::sealed`], /// [`crate::lighting::solid_surface`])? Under colored lights, when any facet takes a smooth light /// ramp. fn underlaid(facets: &[Facet], colored: bool) -> bool { colored && facets.iter().any(|f| f.rgb_gradient.is_some()) } /// The most paint copies `surface` makes for one facet ([`facet_copies`]). const MAX_FACET_COPIES: usize = 12; /// Paint copies `surface` makes for `facets`: two per facet (fill and seam stroke), twice that when /// the facets lie over an underlay of themselves, and [`MAX_FACET_COPIES`] when colored lights also /// give each facet derived paints in three channels (`lighting::solid_surface`). fn facet_copies(facets: &[Facet], paint: &Paint, colored: bool) -> usize { let per_facet = match (underlaid(facets, colored), paint.color().is_some()) { (true, true) => MAX_FACET_COPIES, (true, false) => 4, (false, _) => 2, }; facets.len().saturating_mul(per_facet) } /// The area `item` paints on `path`, and the rule that fills it: the path itself for a fill, the /// stroke's outline (whose contours nest as its holes do) for a stroke. fn region(path: &PathData, rule: FillRule, item: &AppearanceItem) -> (PathData, FillRule) { match item { AppearanceItem::Stroke(s) if s.width > 0.0 && s.width.is_finite() => (crate::stroke::outline_region(path, rule, s), FillRule::EvenOdd), _ => (path.clone(), rule), } } /// One part of [`solid_parts`]: a fill or stroke, its shape's opacity, the region it paints and its /// fill rule, its shape's scopes and the index of its shape. type Part<'a> = (&'a AppearanceItem, f32, PathData, FillRule, &'a [Scope], usize); /// The parts Extrude & Bevel and Inflate build solids from: each shape's top fill and its strokes, /// a group's members from the back up, each with its shape's opacity, the region it paints and its /// shape's scopes. The solids share the bounds of all their parts (`fallback` when none has any): /// one center to turn, twist and taper about, and Inflate's grid reaches over the strokes' outlines. fn solid_parts(shapes: &[Profile], fallback: Rect) -> (Vec>, Rect) { let parts: Vec = shapes .iter() .enumerate() .flat_map(|(member, s)| { let top_fill = s.items.iter().rposition(|i| matches!(i, AppearanceItem::Fill(_))); s.items.iter().enumerate().filter(move |(k, i)| Some(*k) == top_fill || matches!(i, AppearanceItem::Stroke(_))).map(move |(_, i)| { let (area, rule) = region(&s.path, s.rule, i); (i, s.opacity, area, rule, s.scopes.as_slice(), member) }) }) .collect(); let bounds = parts.iter().filter_map(|(_, _, area, _, _, _)| area.bounds()).reduce(|a, c| a.union(c)).unwrap_or(fallback); (parts, bounds) } #[cfg(test)] thread_local! { /// How many solids [`built_solids`] and [`meshes_for`] have built on this thread, for the tests. /// Rotate's planes drawn, the solids built to cast a shadow ([`cast_shadow`]) and Revolve's /// surfaces count too. pub(crate) static SOLIDS_BUILT: std::cell::Cell = const { std::cell::Cell::new(0) }; /// How many Extrude & Bevel (Classic included) and Inflate solids [`facets`] and /// [`built_solids`] have built on this thread, for the tests. static SOLID_GEOMETRY_BUILT: std::cell::Cell = const { std::cell::Cell::new(0) }; } /// The solids Extrude & Bevel (Classic included) or Inflate `id` with parameters `p` builds from /// `parts` ([`solid_parts`]) about `bounds`, one result for each part in order, each built only as /// the iterator reaches it. A stroke's solid past its own limits is `None` (left out of the art, its /// faces not counted); a fill's is an error. The faces of the solids kept count together: once they /// pass `limit` ([`MAX_OBJECT_FACES`] for the art) the result is an error, and /// no later part is built. An error ends the iterator. fn built_solids<'a>( id: &'a str, p: &'a Value, parts: &'a [Part<'a>], bounds: Rect, limit: usize, ) -> impl Iterator>, String>> + 'a { built_solids_cast(id, p, parts, bounds, limit, false).map(|r| r.map(|s| s.map(|(f, _)| f))) } /// One solid's facets and, when its shadow is cast, the faces it is cast from. type CastingSolid = (Vec, Option); /// The surfaces of an object's solids, and the faces each solid kept for its shadow /// ([`surfaces_for`]). type SurfacesAndFaces = (Vec>, Vec>); /// [`built_solids`], and with `cast` for Extrude & Bevel or Inflate each solid's faces its shadow /// is cast from, from the same build ([`SolidFaces`]). fn built_solids_cast<'a>( id: &'a str, p: &'a Value, parts: &'a [Part<'a>], bounds: Rect, limit: usize, cast: bool, ) -> impl Iterator, String>> + 'a { // Inflate's eye is placed for every puff together, as far away as the highest needs. let mut inflated = (id == INFLATE).then(|| -> Box>> { let shapes: Vec<(&PathData, FillRule)> = parts.iter().map(|(_, _, area, rule, _, _)| (area, *rule)).collect(); let (o, view) = (inflate_options(p), view_options(p)); if cast { Box::new(vectorcraft_three_d::inflate_shadowed(&shapes, bounds, o, view).map(|r| r.map(|(f, faces)| (f, Some(faces))))) } else { Box::new(vectorcraft_three_d::inflate_each(&shapes, bounds, o, view).map(|r| r.map(|f| (f, None)))) } }); let mut kept = 0usize; let mut ended = false; parts.iter().map_while(move |(item, _, area, rule, _, _)| { if ended { return None; } #[cfg(test)] SOLIDS_BUILT.with(|n| n.set(n.get() + 1)); let built = match inflated.as_mut() { Some(each) => { #[cfg(test)] SOLID_GEOMETRY_BUILT.with(|n| n.set(n.get() + 1)); each.next().unwrap_or_else(|| Ok((vec![], None))) } None => facets_and_faces(id, area, *rule, bounds, p, cast), }; let result = match built { Ok(f) => { kept = kept.saturating_add(f.0.len()); if kept > limit { Err(vectorcraft_three_d::TOO_COMPLEX_SOLID.to_string()) } else { Ok(Some(f)) } } Err(_) if matches!(item, AppearanceItem::Stroke(_)) => Ok(None), Err(e) => Err(e), }; ended = result.is_err(); Some(result) }) } /// What a face of one of the solids [`art_for`] draws in one order was built from: the facet's /// depth, whether it is a side face and whether it is turned away from the viewer, the bounds of /// its polygon, the index of its shape, and whether its solid is that shape's fill or one of its /// strokes that covers the fill's whole edge. A face that [`convex_face`] takes also keeps its /// polygon and plane, for [`local_order`]; every other face has an empty `outline` and no `plane`. struct Placed { depth: f64, side: bool, away: bool, bounds: Rect, member: usize, paints: Paints, outline: Vec, plane: Option, } /// The part of its shape a face's solid is built from ([`Placed`]). #[derive(Clone, Copy, PartialEq, Eq)] enum Paints { Fill, /// A stroke whose solid holds the fill's whole edge and hides it: one with a width, without /// dashes, a width profile or a brush, painted with a solid color or a gradient without /// transparent stops, on a shape whose subpaths are all closed, extruded (an inflated fill can /// rise in front of its stroke). Stroke, Other, } /// Can a stroke's solid on a shape with outline `path` hold the fill's edge ([`Paints::Stroke`]) /// under the effect `effect`? Only when the subpaths are all closed and the effect extrudes: an /// inflated fill can rise in front of its stroke. fn holds_edge(effect: &str, path: &PathData) -> bool { effect != INFLATE && path.subpaths.iter().all(|p| p.closed) } impl Paints { /// What `item` of a shape is, its stroke's solid able to hold the fill's edge when `closed` /// ([`holds_edge`]). fn of(item: &AppearanceItem, closed: bool) -> Self { match item { AppearanceItem::Fill(_) => Paints::Fill, AppearanceItem::Stroke(s) if closed && s.width > 0.0 && s.width.is_finite() && s.dash.is_none() && s.profile.is_none() && s.brush.is_none() && match &s.paint { Paint::Solid { .. } => true, Paint::Gradient(_) => crate::lighting::opaque_paint(&s.paint).1.is_none(), _ => false, } => { Paints::Stroke } AppearanceItem::Stroke(_) => Paints::Other, } } } impl Placed { /// The face of `f`, of shape `member`'s part `paints`. fn of(f: &Facet, member: usize, paints: Paints) -> Self { let mut points = f.contours.iter().flatten(); let bounds = points.next().map_or(Rect::ZERO, |p| points.fold(Rect::from_points(*p, *p), |r, q| r.union_pt(*q))); let local = convex_face(f).is_some(); let outline = f.contours.first().filter(|_| local).cloned().unwrap_or_default(); let plane = f.plane.filter(|_| local); Placed { depth: f.depth, side: f.side, away: f.away, bounds, member, paints, outline, plane } } } /// The most pairs of faces [`local_order`] compares, and the most [`cut_stroke_faces`] compares; /// the pairs they have not reached by then keep the order of their depths. const MAX_LOCAL_CHECKS: usize = 4_000_000; /// The polygon of `f` and the sign of its turns, when `f` is a face turned toward the viewer other /// than a planar end, with a plane and one convex contour: a face [`local_order`] and /// [`cut_stroke_faces`] work on. fn convex_face(f: &Facet) -> Option<(&[Point], f64)> { if f.away || f.end.is_some() || f.plane.is_none() || f.contours.len() != 1 { return None; } let c = f.contours.first()?; Some((c, convex(c)?)) } /// The bounds of polygon `p` (`Rect::ZERO` when it has no points). fn polygon_bounds(p: &[Point]) -> Rect { let mut points = p.iter(); points.next().map_or(Rect::ZERO, |q| points.fold(Rect::from_points(*q, *q), |r, q| r.union_pt(*q))) } /// Do rectangles `a` and `b` overlap (more than along an edge)? fn rects_overlap(a: Rect, b: Rect) -> bool { a.x0 < b.x1 && b.x0 < a.x1 && a.y0 < b.y1 && b.y0 < a.y1 } /// How many faces [`cut_stroke_faces`] may add to solids painted by `items` that hold `faces` faces /// and whose paint copies take `paint_bytes` so far: as many as keep the faces within /// [`MAX_OBJECT_FACES`] and the copies within the allowance, each added face counted as /// [`MAX_FACET_COPIES`] copies of the costliest stroke's paint. fn cut_room<'a>(items: impl Iterator, faces: usize, paint_bytes: usize) -> usize { let per_face = items .filter(|item| matches!(item, AppearanceItem::Stroke(_))) .map(|item| { let mut copies = 0usize; crate::revolve::paint_copies_add(&mut copies, MAX_FACET_COPIES, paint_ref(item)); copies }) .max() .unwrap_or(0) .max(1); let affordable = crate::revolve::MAX_PAINT_COPIES.saturating_sub(paint_bytes) / per_face; MAX_OBJECT_FACES.saturating_sub(faces).min(affordable) } /// In `solids`, each solid's part ([`Paints`]), its shape's index and its faces, cut each face of a /// stroke that does not cover the fill's edge ([`Paints::Other`]) that passes through the plane of a /// face of the same shape's fill, or of a face of another of the shape's strokes, where the two /// overlap on the drawing ([`cut_through`]). Of two such strokes, the later one's faces are cut /// against the earlier one's; a covering stroke's faces ([`Paints::Stroke`]) are never cut, and an /// other stroke's faces are cut against them. At most `room` pieces are added, the object's solids /// together. fn cut_stroke_faces(solids: &mut [(Paints, usize, &mut Vec)], mut room: usize) { let mut checks = 0usize; for k in 0..solids.len() { let Some((Paints::Other, shape)) = solids.get(k).map(|(p, s, _)| (*p, *s)) else { continue }; let walls: Vec = (0..solids.len()) .filter(|&j| { solids.get(j).is_some_and(|(p, s, _)| { *s == shape && match p { Paints::Fill | Paints::Stroke => true, Paints::Other => j < k, } }) }) .collect(); for j in walls { let (wall, stroke) = if j < k { let (before, from) = solids.split_at_mut(k); (&**before[j].2, &mut *from[0].2) } else { let (before, from) = solids.split_at_mut(j); (&**from[0].2, &mut *before[k].2) }; cut_through(wall, stroke, &mut room, &mut checks); } } } /// Cut each face of `stroke` that passes through the plane of a face of `solid` (the fill's or /// another stroke's) where their polygons overlap on the drawing, along the line where their depths /// meet, so that each piece is wholly in front of or behind that face there ([`local_order`] can /// then order them). A dash's end, which crosses the edge of the fill it is drawn on, is cut into its /// part outside the fill, in front of the fill's wall, and its part inside, behind it. A piece keeps /// the part of the face's curved outline on its side of the cut. The first piece of a face takes its /// place, the others go at the end. Each cut adds a face out of `room`, and each pair compared counts /// in `checks` ([`MAX_LOCAL_CHECKS`]); cutting stops when either runs out. fn cut_through(solid: &[Facet], stroke: &mut Vec, room: &mut usize, checks: &mut usize) { // The faces from left to right: a face is compared with those that start left of its end. let mut walls: Vec<(&Facet, &[Point], f64, Rect)> = solid.iter().filter_map(|f| convex_face(f).map(|(c, turn)| (f, c, turn, polygon_bounds(c)))).collect(); if walls.is_empty() { return; } walls.sort_by(|a, b| a.3.x0.total_cmp(&b.3.x0)); let mut k = 0; while k < stroke.len() { let mut extent = stroke.get(k).and_then(convex_face).map(|(c, _)| polygon_bounds(c)); for &(wall, outline, turn, bounds) in &walls { let Some(at) = extent.filter(|e| bounds.x0 < e.x1) else { break }; if *checks >= MAX_LOCAL_CHECKS || *room == 0 { return; } *checks += 1; if !rects_overlap(at, bounds) { continue; } let Some(s) = stroke.get(k) else { break }; let Some((c, _)) = convex_face(s) else { break }; if let Some((near, far)) = cut(s, c, wall, outline, turn) { *room -= 1; extent = convex_face(&near).map(|(c, _)| polygon_bounds(c)); stroke[k] = near; stroke.push(far); } } k += 1; } } /// Face `s` (polygon `c`) cut where its depth meets that of face `wall` (convex polygon `outline`, /// turning with sign `turn`): its piece nearer the viewer than the wall's plane and its piece /// farther. `None` when the two do not overlap on the drawing or `s` is on one side of the wall's /// plane wherever they do. fn cut(s: &Facet, c: &[Point], wall: &Facet, outline: &[Point], turn: f64) -> Option<(Facet, Facet)> { let ahead = |p: Point| Some(s.depth_at(p)? - wall.depth_at(p)?); let overlap = clip_convex(c, outline, turn); centroid(&overlap)?; let tolerance = 1e-6; let (mut nearer, mut farther) = (false, false); for p in &overlap { let d = ahead(*p)?; nearer |= d > tolerance; farther |= d < -tolerance; } if !(nearer && farther) { return None; } let (a, b) = (s.plane?, wall.plane?); let values: Vec = match (a.eye, b.eye) { (Some(e), Some(f)) if e == f && a.center == b.center => { // With perspective the depths themselves are not linear on the drawing, but where they // meet is a line: (dA - aA e)(nzB - aB) = (dB - aB e)(nzA - aA), with aX = (nX · p) / e, // whose difference is linear. Its sign is that of the depths' difference over the // product of the two denominators, taken at the middle of the face. let at = |p: Point| { let (x, y) = (p.x - a.center.x, p.y - a.center.y); let (aa, ab) = ((a.normal[0] * x + a.normal[1] * y) / e, (b.normal[0] * x + b.normal[1] * y) / e); let (da, db) = (a.normal[2] - aa, b.normal[2] - ab); ((a.offset - aa * e) * db - (b.offset - ab * e) * da, da * db) }; let sign = at(centroid(c)?).1.signum(); c.iter().map(|p| at(*p).0 * sign).collect() } _ => c.iter().map(|p| ahead(*p)).collect::>()?, }; let piece = |sign: f64| { let points = half(c, &values, sign); let mid = centroid(&points)?; let mut f = s.clone(); f.depth = s.depth_at(mid).unwrap_or(s.depth); f.contours = vec![points]; f.outline = s.outline.as_ref().and_then(|o| clip_to_side(o, c, &values, sign)); Some(f) }; Some((piece(1.0)?, piece(-1.0)?)) } /// Curved outline `outline` of a face with polygon `c`, cut along the line where `values` (one per /// point of `c`, varying linearly along each edge) is 0, keeping the side where `sign` times them is /// at least 0. `None` when the line does not cross `c` at two points or nothing is left. fn clip_to_side(outline: &PathData, c: &[Point], values: &[f64], sign: f64) -> Option { let mut crossings = vec![]; for (j, (&a, &va)) in c.iter().zip(values).enumerate() { let k = (j + 1) % c.len(); let (Some(&b), Some(&vb)) = (c.get(k), values.get(k)) else { continue }; if (va >= 0.0) != (vb >= 0.0) { crossings.push(a.lerp(b, va / (va - vb))); } } let &[q0, q1] = crossings.as_slice() else { return None }; let along = q1 - q0; let length = along.hypot(); if length.is_nan() || length <= 1e-9 { return None; } let along = along / length; let (inside, _) = c.iter().zip(values).find(|(_, v)| **v * sign > 0.0)?; let mut across = Vec2::new(-along.y, along.x); if (*inside - q0).dot(across) < 0.0 { across = -across; } let bounds = outline.bounds()?.union(polygon_bounds(c)); let reach = 2.0 * (bounds.width() + bounds.height() + (q0 - bounds.center()).hypot()) + 1.0; let mut side = BezPath::new(); side.move_to(q0 - along * reach); side.line_to(q0 + along * reach); side.line_to(q0 + along * reach + across * reach); side.line_to(q0 - along * reach + across * reach); side.close_path(); let kept = vectorcraft_pathops::boolean(outline, FillRule::NonZero, &PathData::from_bezpath(&side), FillRule::NonZero, BoolOp::Intersect); kept.bounds().is_some().then_some(kept) } /// The part of polygon `p` where `sign` times `values` (one per point, varying linearly along each /// edge) is at least 0. fn half(p: &[Point], values: &[f64], sign: f64) -> Vec { let mut out = vec![]; for (j, (&a, &va)) in p.iter().zip(values).enumerate() { let k = (j + 1) % p.len(); let (Some(&b), Some(&vb)) = (p.get(k), values.get(k)) else { continue }; let (sa, sb) = (va * sign, vb * sign); if sa >= 0.0 { out.push(a); } if (sa >= 0.0) != (sb >= 0.0) { out.push(a.lerp(b, sa / (sa - sb))); } } out } /// `order` (back to front), when it draws a face of one of a shape's strokes and an overlapping face /// of the same shape's fill or strokes the wrong way round for their depths where they overlap on /// the drawing, with every pair of overlapping faces that keep a polygon and a plane /// ([`convex_face`]: turned toward the viewer, not a planar end), of any shape, put in the order of /// their depths where they overlap: the face nearer the viewer there goes after the other. A fill /// wall and a face of the same shape's covering stroke ([`Paints::Stroke`]) keep their order. Each /// face otherwise keeps its place in `order`, so a fill wall in the gap between two dashes stays /// where its depth puts it. A cycle of such pairs is broken at the face that comes first in `order`. /// A face drawn last (a planar end turned toward the viewer, at depth `f64::MAX`) keeps its place: /// no face moves across it. Otherwise `order` as it is. fn local_order(faces: &[Placed], order: Vec) -> Vec { use std::cmp::Reverse; // The faces of each shape that take part, from left to right for a sweep along x. let mut shapes: Vec> = vec![]; for (k, f) in faces.iter().enumerate() { if f.outline.len() < 3 || f.plane.is_none() { continue; } if shapes.len() <= f.member { shapes.resize_with(f.member + 1, Vec::new); } shapes[f.member].push(k); } if !shapes.iter().any(|list| list.iter().any(|&k| faces[k].paints != Paints::Fill)) { return order; } for list in &mut shapes { list.sort_by(|&a, &b| faces[a].bounds.x0.total_cmp(&faces[b].bounds.x0)); } // A fill wall and a face of the same shape's covering stroke keep the order [`draw_order`] gave // them: the stroke's solid holds the wall, which never shows. let covered = |f: &Placed, s: &Placed| f.paints == Paints::Fill && f.side && s.paints == Paints::Stroke && f.member == s.member; // Is there a face of a shape's strokes and a face of the same shape's fill or strokes that the // order of their depths draws the wrong way round where they overlap? let mut position = vec![0usize; faces.len()]; for (at, &k) in order.iter().enumerate() { position[k] = at; } let mut checks = 0usize; let mut misordered = false; 'shapes: for list in &shapes { for (i, &f) in list.iter().enumerate() { let a = &faces[f]; for &s in list.iter().skip(i + 1).take_while(|&&s| faces[s].bounds.x0 < a.bounds.x1) { if checks >= MAX_LOCAL_CHECKS { break 'shapes; } checks += 1; let b = &faces[s]; if (a.paints == Paints::Fill && b.paints == Paints::Fill) || covered(a, b) || covered(b, a) || !rects_overlap(a.bounds, b.bounds) { continue; } if nearer_where_overlapping(a, b).is_some_and(|a_nearer| a_nearer != (position[f] > position[s])) { misordered = true; break 'shapes; } } } } if !misordered { return order; } // Moving those faces must not carry them past any other face they overlap, so every pair of // faces with a polygon and a plane that overlap goes in the order of their depths there. let mut sweep: Vec = (0..faces.len()).filter(|&k| faces[k].outline.len() >= 3 && faces[k].plane.is_some()).collect(); sweep.sort_by(|&a, &b| faces[a].bounds.x0.total_cmp(&faces[b].bounds.x0)); // For each face, the faces drawn after it, and for each, how many go before it. let mut after: Vec> = vec![vec![]; faces.len()]; let mut waits = vec![0usize; faces.len()]; 'pairs: for (i, &k) in sweep.iter().enumerate() { let a = &faces[k]; for &j in sweep.iter().skip(i + 1).take_while(|&&j| faces[j].bounds.x0 < a.bounds.x1) { if checks >= MAX_LOCAL_CHECKS { break 'pairs; } checks += 1; let b = &faces[j]; if !rects_overlap(a.bounds, b.bounds) { continue; } let a_later = if covered(a, b) || covered(b, a) { position[k] > position[j] } else { let Some(a_nearer) = nearer_where_overlapping(a, b) else { continue }; a_nearer }; let (back, front) = if a_later { (j, k) } else { (k, j) }; after[back].push(front); waits[front] += 1; } } // Each step draws the face that comes first in `order` of those whose faces before are drawn. let mut ready: std::collections::BinaryHeap> = (0..faces.len()).filter(|&k| waits[k] == 0).map(|k| Reverse((position[k], k))).collect(); // The faces drawn last, in `order`: each goes only after every face before it in `order`. let last: Vec = order.iter().copied().filter(|&k| faces[k].depth >= f64::MAX).collect(); let mut next_last = 0usize; let mut drawn = vec![false; faces.len()]; let mut out = Vec::with_capacity(order.len()); let mut first = 0usize; while out.len() < order.len() { while last.get(next_last).is_some_and(|&k| drawn[k]) { next_last += 1; } let limit = last.get(next_last).map_or(usize::MAX, |&k| position[k]); let k = match ready.peek() { Some(&Reverse((at, k))) if at < limit => { ready.pop(); k } _ => { // A cycle, or the faces left to draw before a face drawn last wait for faces after // it: the first face in `order` not drawn yet goes next. while order.get(first).is_some_and(|&k| drawn[k]) { first += 1; } let Some(&k) = order.get(first) else { break }; k } }; if drawn[k] { continue; } drawn[k] = true; out.push(k); for &j in &after[k] { waits[j] = waits[j].saturating_sub(1); if waits[j] == 0 && !drawn[j] { ready.push(Reverse((position[j], j))); } } } out } /// Whether face `a` is nearer the viewer than face `b` where their polygons overlap on the drawing, /// measured at the middle of the overlap. `None` when they do not overlap, when either polygon is /// not convex, or when they are at the same depth there. fn nearer_where_overlapping(a: &Placed, b: &Placed) -> Option { let (pa, pb) = (a.plane?, b.plane?); let turn = convex(&b.outline)?; convex(&a.outline)?; let overlap = clip_convex(&a.outline, &b.outline, turn); let mid = centroid(&overlap)?; let (da, db) = (pa.depth_at(mid)?, pb.depth_at(mid)?); let tolerance = 1e-6 * (1.0 + da.abs().max(db.abs())); ((da - db).abs() > tolerance).then_some(da > db) } /// The sign of the turns of convex polygon `p` (`None` when it is not convex or has no area). fn convex(p: &[Point]) -> Option { let n = p.len(); let mut sign = 0.0; for i in 0..n { let (a, b, c) = (p[i], p[(i + 1) % n], p[(i + 2) % n]); let cross = (b - a).cross(c - b); if cross.abs() <= 1e-12 { continue; } if sign == 0.0 { sign = cross.signum(); } else if cross.signum() != sign { return None; } } (sign != 0.0).then_some(sign) } /// The part of polygon `subject` inside convex polygon `clip`, whose turns have sign `turn` /// (Sutherland–Hodgman). fn clip_convex(subject: &[Point], clip: &[Point], turn: f64) -> Vec { let mut out = subject.to_vec(); for i in 0..clip.len() { if out.is_empty() { break; } let (e0, e1) = (clip[i], clip[(i + 1) % clip.len()]); let side = |p: Point| (e1 - e0).cross(p - e0) * turn; let input = std::mem::take(&mut out); for j in 0..input.len() { let (p, q) = (input[j], input[(j + 1) % input.len()]); let (sp, sq) = (side(p), side(q)); if sp >= 0.0 { out.push(p); } if (sp >= 0.0) != (sq >= 0.0) { let t = sp / (sp - sq); out.push(p.lerp(q, t)); } } } out } /// The centroid of polygon `p`, `None` when it has (almost) no area. It is measured from the /// polygon's first point, so a small polygon far from the origin keeps its area. fn centroid(p: &[Point]) -> Option { let origin = *p.first()?; let n = p.len(); let (mut area, mut cx, mut cy) = (0.0, 0.0, 0.0); for i in 0..n { let (a, b) = (p[i] - origin, p[(i + 1) % n] - origin); let cross = a.x * b.y - b.x * a.y; area += cross; cx += (a.x + b.x) * cross; cy += (a.y + b.y) * cross; } (area.abs() > 1e-9).then(|| origin + Vec2::new(cx / (3.0 * area), cy / (3.0 * area))) } /// The most bounds comparisons [`draw_order`] makes; the fill walls it has not reached by then keep /// their depths. const MAX_OVERLAP_CHECKS: usize = 4_000_000; /// The order faces `faces` are drawn in, back to front, as indices into `faces`: by depth (faces /// at the same depth in the order given), except that with `sealed` (solids with caps) a side face /// of a shape's fill turned toward the viewer is drawn before each face of the same shape's /// covering strokes ([`Paints::Stroke`]), turned toward the viewer, whose bounds overlap its own. /// Such a stroke's closed solid holds the fill's walls, so they never show and can be drawn under /// any other face. A shape's fill faces and the faces of its other strokes then go in the order of /// their depths where they overlap ([`local_order`]). fn draw_order(faces: &[Placed], sealed: bool) -> Vec { // Each face's depth to sort by, and whether it was moved before a stroke face at that depth. let mut keys: Vec<(f64, bool)> = faces.iter().map(|f| (f.depth, false)).collect(); if sealed { // The stroke faces turned toward the viewer of each shape, nearest last. let mut strokes: Vec> = vec![]; for f in faces.iter().filter(|f| f.paints == Paints::Stroke && !f.away) { if strokes.len() <= f.member { strokes.resize_with(f.member + 1, Vec::new); } strokes[f.member].push(f); } for list in &mut strokes { list.sort_by(|a, b| a.depth.total_cmp(&b.depth)); } let overlap = |a: &Rect, b: &Rect| a.x0 < b.x1 && b.x0 < a.x1 && a.y0 < b.y1 && b.y0 < a.y1; let mut checks = 0usize; for (f, key) in faces.iter().zip(&mut keys) { if f.paints != Paints::Fill || !f.side || f.away { continue; } let Some(list) = strokes.get(f.member).filter(|l| !l.is_empty()) else { continue }; for s in list.iter().take_while(|s| s.depth <= f.depth) { if checks >= MAX_OVERLAP_CHECKS { break; } checks += 1; if overlap(&s.bounds, &f.bounds) { *key = (s.depth, true); break; } } } } let mut order: Vec = (0..faces.len()).collect(); // A stable sort: faces at the same depth keep the order of the appearance, and a fill's side // face moved to a stroke face's depth goes before it. order.sort_by(|&a, &b| keys[a].0.total_cmp(&keys[b].0).then(keys[b].1.cmp(&keys[a].1))); local_order(faces, order) } /// The order, back to front, of the faces of one or more Revolve surfaces `faces`, given back to /// front by depth: each face's polygon on the drawing, its plane and its depth. When two /// overlapping faces are drawn the wrong way round for their depths where they overlap, every pair /// of overlapping faces with a convex polygon and a plane goes in the order of its depths there, /// the face nearer the viewer after the other ([`local_order`]), and each step draws the face that /// comes first in the given order of those whose faces before are drawn, so a face without a plane /// or a convex polygon can also move. Otherwise the order given. pub(crate) fn surface_order<'a>(faces: impl IntoIterator, f64)>) -> Vec { let placed: Vec = faces .into_iter() .map(|(points, plane, depth)| { let local = plane.is_some() && convex(points).is_some(); // Every face counts as one of a stroke's on one shape, so each overlapping pair is compared. Placed { depth, side: true, away: false, bounds: polygon_bounds(points), member: 0, paints: Paints::Other, outline: if local { points.to_vec() } else { vec![] }, plane: plane.filter(|_| local), } }) .collect(); let order = (0..placed.len()).collect(); local_order(&placed, order) } /// `shapes`, the members of group or layer `n`, reshaped by the visible geometry effects `before` /// its 3D effect, about the bounds of all of them. pub(crate) fn reshape_members(n: &Node, before: &[Effect], shapes: &mut [Profile]) { if before.iter().any(|e| e.visible && is_geometry(&e.id)) && let Some(b) = union_bounds(shapes) { let ctx = GeomContext::of(n); for s in shapes { s.path = apply_geometry_with(before, &s.path, b, &ctx); } } } /// A 3D effect's shadow and its surfaces ([`art_for`]). type ShadowAndSurfaces = (Vec>, Vec>); /// The 3D art of one effect `fx` on `path` (already through the effects before it). /// Rotate turns every fill and stroke, each in its own paint. Extrude & Bevel and Inflate build a /// solid from the path for the top visible fill and one from the outline of each visible stroke, /// each in its own paint. When every one is opaque with normal blending, their faces are drawn in /// one back-to-front order, a solid color under colored lights included up to /// [`MAX_FACE_COMPOSITES`] facets (where depths tie, as /// for the caps turned toward the viewer, in the order of the appearance, and with caps, a shape's /// fill walls before the faces of its covering strokes that overlap them, and its fill's faces and /// its other strokes' faces, cut where they pass through each other ([`cut_stroke_faces`]), in the /// order of their depths where they overlap: [`draw_order`]), the /// faces of a solid in a gradient with transparent stops in runs that carry its opacity mask /// ([`in_runs`]); /// otherwise each solid is a surface of its own, in that order. A member's opacity mask and /// blending mode, and those of a group it is in, apply to the surfaces of the members it holds /// ([`masked`]). The art comes in two parts: the effect's shadow ([`cast_shadow`], none with it /// off), cast from the faces the solids drawn kept ([`cast_built`]), to be drawn behind every /// surface of the object, and the surfaces. fn art_for(doc: Option<&Document>, n: &Node, fx: &Effect, shapes: &[Profile]) -> Option { // In wireframe mode the effect draws the edges of the faces it builds, with no shadow. if wireframe::renders_wireframe(fx) { return Some((vec![], wireframe::wire_surfaces(n.id, fx, shapes)?)); } let p = crate::merged_params(&fx.id, &fx.params); let cast = !is_classic_three_d(&fx.id) && shadow::options(&p).is_some(); let (art, built) = surfaces_for(doc, n, fx, shapes, cast)?; // A shadow past the limits draws the source path, as a solid past them does; commands report // the error ([`validate_solid_in`]). let shadow = if cast { cast_built(&fx.id, &p, shapes, built) } else { Ok(None) }; let shadow = match shadow.ok()? { Some((caster, settings, cast)) => shadow::scoped_art(n.id, &caster, settings, cast, has_masks(shapes)), None => vec![], }; Some((shadow, art)) } /// The shadow [`art_for`] draws for effect `fx` on `shapes` behind the surfaces of object `id`: /// none with the shadow off or in wireframe mode, and an error when it is past the limits. pub(crate) fn shadow_for(id: NodeId, fx: &Effect, shapes: &[Profile]) -> Result>, String> { if wireframe::renders_wireframe(fx) { return Ok(vec![]); } Ok(match cast_shadow(&fx.id, &crate::merged_params(&fx.id, &fx.params), shapes)? { Some((caster, settings, cast)) => shadow::scoped_art(id, &caster, settings, cast, has_masks(shapes)), None => vec![], }) } /// What the shadow of the solids [`surfaces_for`] builds for effect `id` with parameters `p` on /// `shapes` is cast from, on one plane: the faces of every solid, the shadow's settings and the /// faces of each solid of visible art with its member's scopes and ink. `None` with the shadow /// off, for Extrude & Bevel (Classic) and Rotate (Classic) or with no shapes. A stroke's solid that is not built (past /// the limits) casts nothing, as it draws nothing; any other solid that is not built is an error. /// When a member's opacity mask or blending mode applies to its solids ([`masked`]), it applies to /// the part of the shadow they cast too ([`shadow::scoped_art`]). fn cast_shadow<'a>(id: &str, p: &Value, shapes: &'a [Profile]) -> Result>, String> { if id == CLASSIC_EXTRUDE || id == CLASSIC_ROTATE { return Ok(None); } let (Some(settings), Some(b)) = (shadow::options(p), union_bounds(shapes)) else { return Ok(None) }; let view = view_options(p); let mut caster = vectorcraft_three_d::ShadowCaster::new(); // The faces each solid of visible art added, with its member's scopes and its ink (opacity // and blending mode), in order. A fully transparent fill or stroke (or member) casts nothing // and does not place the plane. let mut cast: Vec = vec![]; let ink = |item: &AppearanceItem, member: f32| { let (_, opacity, blend) = paint_of(item, member); shadow::Ink { opacity, blend } }; if id == ROTATE { for s in shapes { for item in s.items.iter().filter(|i| ink(i, s.opacity).opacity > 0.0) { let (area, rule) = region(&s.path, s.rule, item); #[cfg(test)] SOLIDS_BUILT.with(|n| n.set(n.get() + 1)); let faces = caster.plane(&area, rule, b, view)?; cast.push((s.scopes.as_slice(), ink(item, s.opacity), faces)); } } } else { let (parts, bounds) = solid_parts(shapes, b); let inks: Vec = parts.iter().map(|(item, member, ..)| ink(item, *member)).collect(); // Inflate's eye is placed for every shape together, as the solids are. let added: Vec, String>> = if id == INFLATE { let shapes: Vec<(&PathData, FillRule)> = parts.iter().map(|(_, _, area, rule, _, _)| (area, *rule)).collect(); let casts: Vec = inks.iter().map(|i| i.opacity > 0.0).collect(); #[cfg(test)] SOLIDS_BUILT.with(|n| n.set(n.get() + shapes.len())); caster.inflate(&shapes, &casts, bounds, inflate_options(p), view) } else { let mut added = vec![]; for ((_, _, area, rule, _, _), ink) in parts.iter().zip(&inks) { #[cfg(test)] SOLIDS_BUILT.with(|n| n.set(n.get() + usize::from(ink.opacity > 0.0))); added.push(if ink.opacity > 0.0 { caster.extrude(area, *rule, bounds, extrude_options(p), view) } else { Ok(0..0) }); } added }; for (((item, _, _, _, scopes, _), ink), faces) in parts.iter().zip(inks).zip(added) { if ink.opacity <= 0.0 { continue; } // A stroke whose own solid is past the limits is left out; past the shadow's limit for // all the solids together, the shadow is refused. let faces = match faces { Ok(faces) => faces, Err(e) if matches!(item, AppearanceItem::Stroke(_)) && e != vectorcraft_three_d::TOO_COMPLEX_SHADOW => continue, Err(e) => return Err(e), }; cast.push((*scopes, ink, faces)); } } Ok(Some((caster, settings, cast))) } /// [`cast_shadow`] from `built`, the faces the solids drawn kept ([`surfaces_for`] with its shadow /// cast), one entry for each solid in the order they are built: for Rotate each fill and stroke of /// each shape, otherwise each part ([`solid_parts`]). A stroke's solid left out of the art (past its /// own limits) kept no faces. Its Extrude & Bevel solid is built for the shadow alone, as /// [`cast_shadow`] builds it, and when an Inflate solid of visible art kept no faces the whole /// shadow is cast as [`cast_shadow`] casts it, since Inflate's solids share one eye. fn cast_built<'a>(id: &str, p: &Value, shapes: &'a [Profile], built: Vec>) -> Result>, String> { if id == CLASSIC_EXTRUDE || id == CLASSIC_ROTATE { return Ok(None); } let (Some(settings), Some(b)) = (shadow::options(p), union_bounds(shapes)) else { return Ok(None) }; let view = view_options(p); let mut caster = vectorcraft_three_d::ShadowCaster::new(); let mut cast: Vec = vec![]; let ink = |item: &AppearanceItem, member: f32| { let (_, opacity, blend) = paint_of(item, member); shadow::Ink { opacity, blend } }; if id == ROTATE { let items: Vec<(&Profile, &AppearanceItem)> = shapes.iter().flat_map(|s| s.items.iter().map(move |item| (s, item))).collect(); if items.len() != built.len() { return cast_shadow(id, p, shapes); } for ((s, item), kept) in items.into_iter().zip(built) { let ink = ink(item, s.opacity); if ink.opacity <= 0.0 { continue; } let faces = match kept { Some(kept) => caster.add_solid(kept)?, None => { let (area, rule) = region(&s.path, s.rule, item); #[cfg(test)] SOLIDS_BUILT.with(|n| n.set(n.get() + 1)); caster.plane(&area, rule, b, view)? } }; cast.push((s.scopes.as_slice(), ink, faces)); } return Ok(Some((caster, settings, cast))); } let (parts, bounds) = solid_parts(shapes, b); let inks: Vec = parts.iter().map(|(item, member, ..)| ink(item, *member)).collect(); if parts.len() != built.len() || (id == INFLATE && inks.iter().zip(&built).any(|(ink, kept)| ink.opacity > 0.0 && kept.is_none())) { return cast_shadow(id, p, shapes); } for (((item, _, area, rule, scopes, _), ink), kept) in parts.iter().zip(inks).zip(built) { if ink.opacity <= 0.0 { continue; } let faces = match kept { Some(kept) => caster.add_solid(kept), None => { #[cfg(test)] SOLIDS_BUILT.with(|n| n.set(n.get() + 1)); caster.extrude(area, *rule, bounds, extrude_options(p), view) } }; // A stroke whose own solid is past the limits is left out; past the shadow's limit for all // the solids together, the shadow is refused. let faces = match faces { Ok(faces) => faces, Err(e) if matches!(item, AppearanceItem::Stroke(_)) && e != vectorcraft_three_d::TOO_COMPLEX_SHADOW => continue, Err(e) => return Err(e), }; cast.push((*scopes, ink, faces)); } Ok(Some((caster, settings, cast))) } /// The faces a shadow is cast from, its settings, and the faces of each solid of visible art with /// its member's scopes and ink ([`cast_shadow`]). type Cast<'a> = (vectorcraft_three_d::ShadowCaster, vectorcraft_three_d::Shadow, Vec>); /// The graphics of a 3D effect with parameters `p`, drawn on its faces ([`graphics::face_art`]): /// for each planar face with a graphic, the art and the face. `caps` are the faces the viewer sees /// of the ends of the object's solids, each with its end; `bounds` are the bounds the solids were /// built with; `opacity` is the opacity of the fill or stroke those solids are painted with, which /// the graphics take too. `elements` is the effect's count of drawn path elements, shared by every /// call for one effect ([`graphics::face_art`]). fn graphic_art( doc: Option<&Document>, id: NodeId, (effect, p): (&str, &Value), bounds: Rect, caps: &[&Facet], opacity: f32, elements: &mut usize, ) -> Vec<(PlanarFace, Arc)> { let list = graphics::mapped_graphics(p); if list.is_empty() || !takes_graphics(effect) { return vec![]; } let view = view_options(p); PlanarFace::ALL .into_iter() .filter_map(|face| { let on: Vec<&Facet> = caps.iter().copied().filter(|f| f.end == Some(face)).collect(); let map = if effect == ROTATE { vectorcraft_three_d::plane_face_map(bounds, view) } else { vectorcraft_three_d::extrude_face_map(bounds, extrude_options(p), view, face) }?; graphics::face_art(doc, id, &list, (face, &map), bounds.center(), &on, elements).map(|mut art| { art.opacity *= opacity; (face, Arc::new(art)) }) }) .collect() } /// A solid (a fill's or a stroke's) with ends the viewer sees: the index of its surface, its /// member, the ends, the opacity and blending mode of its fill or stroke, and whether its surface /// carries an opacity mask (a gradient's transparency under a colored light, [`surface`]). struct Filled { at: usize, member: usize, caps: Vec, opacity: f32, blend: BlendMode, masked: bool, } /// Does a surface in `paint` carry an opacity mask ([`surface`])? fn masks_surface(paint: &Paint, colored: bool) -> bool { colored && crate::lighting::opaque_paint(paint).1.is_some() } /// A graphic of [`placed_graphics`]: the index of the first surface of the solids that share it, /// the index of the surface it is drawn right after, its face and its art. type Placement = (usize, usize, PlanarFace, Arc); /// The graphics of the solids `filled` ([`graphic_art`]), each with the index of the surface it is /// drawn right after (the last of those solids holding its face) and its face. Solids in a run /// with the same opacity and blending mode share their graphics, one on each face. With /// `per_member` (a member's opacity mask or blending mode applies to its surfaces) each member's /// solids get graphics of their own, clipped to that member's caps, so they stay in that member's /// scopes. All the groups share one limit on the path elements drawn: once it is reached, later /// groups draw no graphics. fn placed_graphics(doc: Option<&Document>, id: NodeId, effect: (&str, &Value), bounds: Rect, filled: &[Filled], per_member: bool) -> Vec { let mut groups: Vec> = vec![]; for f in filled { // Solids whose fills or strokes differ in opacity or blending mode get graphics of their // own, each drawn as its fill or stroke is. One member's solids share their graphics // whether or not their surfaces carry an opacity mask, and each graphic takes the mask of // the surface it is drawn after ([`with_graphics`]). Solids of different members share // them only when neither surface carries a mask. A solid joins only the group of the solid // before it, so a graphic is never drawn past a solid painted between. let joins = |g: &&Filled| { let member = g.member == f.member; (member || !per_member && !g.masked && !f.masked) && g.opacity == f.opacity && g.blend == f.blend }; match groups.last_mut().filter(|g| g.iter().all(joins)) { Some(g) => g.push(f), None => groups.push(vec![f]), } } let mut out = vec![]; let mut elements = 0usize; for group in groups { let caps: Vec<&Facet> = group.iter().flat_map(|f| &f.caps).collect(); let first = group.first().map_or(0, |f| f.at); let opacity = group.first().map_or(1.0, |f| f.opacity); let blend = group.first().map_or(BlendMode::Normal, |f| f.blend); for (face, mut art) in graphic_art(doc, id, effect, bounds, &caps, opacity, &mut elements) { if let Some(f) = group.iter().rev().find(|f| f.caps.iter().any(|c| c.end == Some(face))) { Arc::make_mut(&mut art).blend = blend; out.push((first, f.at, face, art)); } } } out } /// One solid's surface as [`surfaces_for`] builds it: its faces' depths, its art, its member's /// scopes, and for each face the end of a solid it is, when the viewer sees it. type BuiltSurface<'s> = (Vec, Node, &'s [Scope], Vec>); /// [`with_graphics`] of built surfaces, each drawn whole. fn whole_surfaces<'s>(surfaces: Vec>, arts: &[Placement]) -> Vec<(&'s [Scope], Arc)> { with_graphics(surfaces.into_iter().map(|(_, s, scopes, _)| (scopes, Arc::new(s))).collect(), 0, arts) } /// `surfaces` (those from index `first`) drawn whole, each with its scopes, and the graphics `arts` /// ([`placed_graphics`]) of those surfaces each right after its surface, with that surface's scopes /// and its opacity mask (a gradient's transparency), so a graphic is hidden where its cap is. fn with_graphics<'s>(surfaces: Vec<(&'s [Scope], Arc)>, first: usize, arts: &[Placement]) -> Vec<(&'s [Scope], Arc)> { let mut out = Vec::with_capacity(surfaces.len() + arts.len()); for (k, (scopes, s)) in surfaces.into_iter().enumerate() { let mask = s.extras().mask.clone(); out.push((scopes, s)); out.extend(arts.iter().filter(|(_, at, ..)| *at == first + k).map(|(.., art)| { let mut art = art.clone(); if let Some(mask) = &mask { Arc::make_mut(&mut art).extras_mut().mask = Some(mask.clone()); } (scopes, art) })); } out } /// The ends of `f` the viewer sees, for a fill's solid or a stroke's: where its graphics go. fn seen_ends(f: &[Facet]) -> impl Iterator { f.iter().filter(|f| f.end.is_some() && !f.away) } /// [`art_for`] without the shadow: the solids' surfaces, with the graphics mapped onto their planar /// faces drawn right after the last of the solids' surfaces that holds that face. With `cast`, each /// solid built also keeps the faces its shadow is cast from, from the same build, in the order the /// solids are built ([`cast_built`]); `None` for a stroke's solid left out of the art. fn surfaces_for(doc: Option<&Document>, n: &Node, fx: &Effect, shapes: &[Profile], cast: bool) -> Option { let b = union_bounds(shapes)?; let p = crate::merged_params(&fx.id, &fx.params); let classic = fx.id == CLASSIC_EXTRUDE || fx.id == CLASSIC_ROTATE; let colored = !classic && view_options(&p).has_colored_lights(); let masks = has_masks(shapes); // The paint copies of every solid together: past the allowance the source path is drawn. let mut paint_bytes = 0usize; // The caps are copied only when the effect has graphics to draw on them. let graphics_on = !classic && takes_graphics(&fx.id) && !mapped_graphics(&p).is_empty(); if is_plane(&fx.id) { // Every part turns about the centre of the object's own bounds (a group's members about // the centre of theirs), so they stay together. let mut out = vec![]; let mut filled = vec![]; let mut built = vec![]; for (member, s) in shapes.iter().enumerate() { for item in &s.items { let (paint, opacity, blend) = paint_of(item, s.opacity); let (area, rule) = region(&s.path, s.rule, item); #[cfg(test)] SOLIDS_BUILT.with(|n| n.set(n.get() + 1)); let (f, faces) = facets_and_faces(ROTATE, &area, rule, b, &p, cast).ok()?; built.push(faces); if !crate::revolve::paint_copies_add(&mut paint_bytes, facet_copies(&f, &paint, colored), &paint) { return None; } if graphics_on { let caps: Vec = seen_ends(&f).cloned().collect(); if !caps.is_empty() { filled.push(Filled { at: out.len(), member, caps, opacity, blend, masked: masks_surface(&paint, colored) }); } } let art = if classic { classic::surface(n, f, &paint, opacity, blend, &p) } else { surface(n, f, &paint, opacity, blend, colored, false) }; out.push((s.scopes.as_slice(), Arc::new(art))); } } let arts = placed_graphics(doc, n.id, (ROTATE, &p), b, &filled, masks); let out = with_graphics(out, 0, &arts); return Some((if masks { masked(n.id, out) } else { out.into_iter().map(|(_, s)| s).collect() }, built)); } let (parts, bounds) = solid_parts(shapes, b); let mut solids = vec![]; let mut built = vec![]; for ((item, opacity, _, _, scopes, member), f) in parts.iter().zip(built_solids_cast(&fx.id, &p, &parts, bounds, MAX_OBJECT_FACES, cast)) { let item: &AppearanceItem = item; match f { Ok(Some((f, _))) if !crate::revolve::paint_copies_add(&mut paint_bytes, facet_copies(&f, paint_ref(item), colored), paint_ref(item)) => { return None; } Ok(Some((f, faces))) => { solids.push((item, *opacity, *scopes, f, *member)); built.push(faces); } // A stroke's outline past the limits is left out; the fill's solid still draws. Ok(None) => built.push(None), // A loaded file or a shape edited past the limits (its own, or those of the object's // solids together) keeps drawing its source path instead of failing the frame; // commands validate the same evaluator and report its errors. Err(_) => return None, } } if solids.is_empty() { return None; } let opaque = solids.iter().all(|(item, member, _, _, _)| { let (_, opacity, blend) = paint_of(item, *member); opacity >= 1.0 && blend == BlendMode::Normal }); let closed = |shape: usize| shapes.get(shape).is_some_and(|s| holds_edge(&fx.id, &s.path)); // A solid color under colored lights with smooth shading draws as one composite of its facets // ([`surface`]) unless its facets go in one order with other solids' faces. They do while all // such facets together number at most MAX_FACE_COMPOSITES. let composite = |item: &AppearanceItem, f: &[Facet]| composites_facets(f, paint_ref(item), colored); let colored_faces: usize = solids.iter().filter(|(item, _, _, f, _)| composite(item, f)).map(|(.., f, _)| f.len()).sum(); let split = colored_faces <= MAX_FACE_COMPOSITES; // The faces are drawn in one order (below) when every solid is opaque and blends normally and // no composite draws a surface whole. Under a member's opacity mask or blending, each member's // faces go in one order of their own when its fills and strokes are opaque, blend normally, // carry no opacity mask and are not composites. let one_order = opaque && (split || !solids.iter().any(|(item, _, _, f, _)| composite(item, f))); let shape_order: Vec = (0..shapes.len()) .map(|shape| { solids.iter().filter(|s| s.4 == shape).all(|(item, member, _, f, _)| { let (paint, opacity, blend) = paint_of(item, *member); opacity >= 1.0 && blend == BlendMode::Normal && !masks_surface(&paint, colored) && (split || !composite(item, f)) }) }) .collect(); let ordered = |shape: usize| if masks { shape_order.get(shape).copied().unwrap_or(false) } else { one_order }; // The solids whose faces share one order with another solid's: every solid in the one order of // the object, or of its member under a mask. A lone solid draws its facets in their own order, // so a solid color under colored lights stays one composite there ([`surface`]). let shared: Vec = (0..shapes.len()).map(|shape| ordered(shape) && solids.iter().filter(|s| !masks || s.4 == shape).nth(1).is_some()).collect(); if solids.iter().any(|s| ordered(s.4)) { // A stroke face that passes through a fill wall or another stroke's face is cut where it // does. The pieces count against the limits as the faces did: cutting stops before the // faces pass MAX_OBJECT_FACES or their paint copies pass the allowance, so an effect that // draws uncut still draws. let counts: Vec = solids.iter().map(|(.., f, _)| f.len()).collect(); let room = cut_room(solids.iter().map(|(item, ..)| *item), counts.iter().sum(), paint_bytes); let mut cuts: Vec<(Paints, usize, &mut Vec)> = solids .iter_mut() .filter(|(.., shape)| ordered(*shape)) .map(|(item, _, _, f, shape)| (Paints::of(item, closed(*shape)), *shape, f)) .collect(); cut_stroke_faces(&mut cuts, room); for ((item, _, _, f, _), before) in solids.iter().zip(counts) { let added = f.get(before..).unwrap_or_default(); if !crate::revolve::paint_copies_add(&mut paint_bytes, facet_copies(added, paint_ref(item), colored), paint_ref(item)) { return None; } } } let arts = if !graphics_on { vec![] } else { let filled: Vec = solids .iter() .enumerate() .filter_map(|(at, (item, member, _, f, shape))| { let caps: Vec = seen_ends(f).cloned().collect(); let (paint, opacity, blend) = paint_of(item, *member); let masked = masks_surface(&paint, colored); (!caps.is_empty()).then_some(Filled { at, member: *shape, caps, opacity, blend, masked }) }) .collect(); placed_graphics(doc, n.id, (&fx.id, &p), bounds, &filled, masks) }; // With the pieces of the cuts, solid colors under colored lights past MAX_FACE_COMPOSITES draw // as one composite each, so their surfaces draw whole (below). let split = split && solids.iter().filter(|(item, _, _, f, _)| composite(item, f)).map(|(.., f, _)| f.len()).sum::() <= MAX_FACE_COMPOSITES; let members: Vec = solids.iter().map(|s| s.4).collect(); // Which surfaces lie over an underlay of their facets, in one order or whole // ([`in_one_order`], [`underlaid_surface`]). let seals: Vec = solids.iter().map(|(.., f, _)| underlaid(f, colored)).collect(); let seal = |range: std::ops::Range| seals.get(range).is_some_and(|s| s.iter().any(|s| *s)); let surfaces: Vec = solids .into_iter() .map(|(item, member, scopes, f, shape)| { let paints = Paints::of(item, closed(shape)); let depths: Vec = f.iter().map(|f| Placed::of(f, shape, paints)).collect(); let ends = f.iter().map(|f| f.end.filter(|_| !f.away)).collect(); let (paint, opacity, blend) = paint_of(item, member); let art = if classic { classic::surface(n, f, &paint, opacity, blend, &p) } else { surface(n, f, &paint, opacity, blend, colored, split && shared.get(shape).copied().unwrap_or(false)) }; (depths, art, scopes, ends) }) .collect(); let sealed = match fx.id.as_str() { INFLATE => inflate_options(&p).cap, CLASSIC_EXTRUDE => classic_extrude_options(&p).cap, _ => extrude_options(&p).cap, }; // One order takes a plain group of faces from each solid, one face for each facet. A lone // solid's surface can instead be one clipped composite of all its facets ([`surface`]), which // has no faces to order, so it draws whole. let plain = |(depths, s, _, _): &BuiltSurface| matches!(&s.kind, NodeKind::Group { children, clip: false } if children.len() == depths.len()); if masks { // Each member's surfaces, in the scopes of its opacity mask or blending: its faces in one // order when it is opaque and plain, otherwise each surface whole. let mut out = vec![]; let mut surfaces = surfaces.into_iter().zip(members).enumerate().peekable(); while let Some((first, (s, member))) = surfaces.next() { let mut run = vec![s]; while let Some((_, (s, _))) = surfaces.next_if(|(_, (_, m))| *m == member) { run.push(s); } let flat = run.iter().all(|s| plain(s) && s.1.opacity >= 1.0 && s.1.blend == BlendMode::Normal && s.1.extras().mask.is_none()); let range = first..first + run.len(); if ordered(member) && flat { let scopes = run.first().map_or(&[][..], |s| s.2); let seals = seals.get(range).unwrap_or_default(); out.push((scopes, Arc::new(Node::group(n.id, in_one_order(n.id, run, first, &arts, sealed, seals))))); } else { let run = run.into_iter().zip(range).map(|((_, s, scopes, _), k)| (scopes, Arc::new(underlaid_surface(n.id, s, seal(k..k + 1))))); out.extend(with_graphics(run.collect(), first, &arts)); } } return Some((masked(n.id, out), built)); } if !opaque || !surfaces.iter().all(plain) { let surfaces = surfaces.into_iter().enumerate().map(|(k, (d, s, scopes, e))| (d, underlaid_surface(n.id, s, seal(k..k + 1)), scopes, e)).collect(); return Some((whole_surfaces(surfaces, &arts).into_iter().map(|(_, s)| s).collect(), built)); } Some((vec![Arc::new(Node::group(n.id, in_one_order(n.id, surfaces, 0, &arts, sealed, &seals)))], built)) } /// A plain `surface` ([`surface`]: a group of its facets) over an underlay of its facets when /// `seal`, keeping the surface's opacity, blend mode and opacity mask. fn underlaid_surface(id: NodeId, surface: Node, seal: bool) -> Node { let NodeKind::Group { children, clip: false } = &surface.kind else { return surface }; let Some(mut out) = seal.then(|| crate::lighting::sealed(id, children)).flatten() else { return surface }; out.opacity = surface.opacity; out.blend = surface.blend; if let Some(mask) = surface.extras().mask.clone() { out.extras_mut().mask = Some(mask); } out } /// The faces of `surfaces` (plain groups of their faces, [`surfaces_for`]'s from index `first`) in /// one order ([`draw_order`], `sealed` for solids with caps), each of the graphics `arts` of those /// surfaces right after the last face it is drawn on, of the surfaces that share it. A surface in a gradient with transparent stops /// carries an opacity mask: its faces go in runs ([`in_runs`]), each carrying the mask, and each of /// its graphics carries the mask too ([`with_graphics`]), so a graphic is hidden where its cap is. /// The faces of the surfaces that `seals` marks lie over underlays of themselves /// ([`underlaid_runs`], [`underlaid_surface`]). fn in_one_order(id: NodeId, surfaces: Vec>, first: usize, arts: &[Placement], sealed: bool, seals: &[bool]) -> Vec> { let masks: Vec>> = surfaces.iter().map(|(_, s, _, _)| s.extras().mask.clone()).collect(); let arts: Vec<&Placement> = arts.iter().filter(|(_, at, ..)| (first..first + surfaces.len()).contains(at)).collect(); let (mut placed, mut faces, mut ends) = (vec![], vec![], vec![]); for (surface, (depths, s, _, e)) in surfaces.into_iter().enumerate() { if let NodeKind::Group { children, .. } = s.kind { placed.extend(depths); faces.extend(children.into_iter().map(|face| Some((surface, face)))); ends.extend(e.into_iter().map(|end| end.map(|end| (surface, end)))); } } let order = draw_order(&placed, sealed); // Each graphic goes right after the last of the faces it is drawn on, among the surfaces that // share it ([`placed_graphics`]): those from the first of them to its own. let last: Vec> = arts .iter() .map(|(from, at, face, _)| { let (from, at) = (from.saturating_sub(first), at - first); order.iter().rposition(|k| ends.get(*k).copied().flatten().is_some_and(|(surface, end)| end == *face && (from..=at).contains(&surface))) }) .collect(); let mut drawn: Vec<(usize, Arc)> = Vec::with_capacity(order.len() + arts.len()); for (at, k) in order.into_iter().enumerate() { drawn.extend(faces.get_mut(k).and_then(Option::take)); drawn.extend(last.iter().zip(&arts).filter(|(l, _)| **l == Some(at)).map(|(_, (_, surface, _, art))| { let mut art = art.clone(); if let Some(mask) = masks.get(surface - first).cloned().flatten() { Arc::make_mut(&mut art).extras_mut().mask = Some(mask); } // An index past the surfaces: the graphic goes in a run of its own, with its own mask. (masks.len(), art) })); } let takes_underlay = |surface: usize| seals.get(surface) == Some(&true); if masks.iter().any(Option::is_some) { // The faces of a surface without a mask are sealed run by run before the masked surfaces' // faces go in runs of their own, each holding one surface's faces, sealed with its mask. let unmasked = underlaid_runs(id, drawn, |s| takes_underlay(s) && masks.get(s).is_some_and(Option::is_none)); return in_runs(id, unmasked, &masks) .into_iter() .map(|run| match &run.kind { NodeKind::Group { clip: false, .. } if seals.iter().any(|s| *s) && run.extras().mask.is_some() => { Arc::new(underlaid_surface(id, (*run).clone(), true)) } _ => run, }) .collect(); } underlaid_runs(id, drawn, takes_underlay).into_iter().map(|(_, face)| face).collect() } /// `faces` in their drawing order, each with the index of its surface. Each run of consecutive /// faces of one surface that `seal` takes lies over an underlay of its own faces, clipped to their /// outline ([`crate::lighting::sealed`]), so no underlay reaches under another surface's faces or a /// graphic drawn between them. A sealed run keeps its surface's index. fn underlaid_runs(id: NodeId, faces: Vec<(usize, Arc)>, seal: impl Fn(usize) -> bool) -> Vec<(usize, Arc)> { let mut out = Vec::with_capacity(faces.len()); let mut run: Vec> = vec![]; let mut faces = faces.into_iter().peekable(); while let Some((surface, face)) = faces.next() { run.push(face); if faces.peek().is_some_and(|(next, _)| *next == surface) { continue; } match seal(surface).then(|| crate::lighting::sealed(id, &run)).flatten() { Some(sealed) => { out.push((surface, Arc::new(sealed))); run.clear(); } None => out.extend(run.drain(..).map(|face| (surface, face))), } } out } /// `faces` in their back-to-front order, each with the index of its surface, where some surfaces /// carry an opacity mask (`masks`, by surface). A face of a surface without one goes in the order /// on its own. The faces of a masked surface share a run, one group with the surface's mask. Such a /// face joins its surface's last run unless a face drawn after that run overlaps it: only then does /// the surface split, where one group can't be both behind and in front of another face. fn in_runs(id: NodeId, faces: Vec<(usize, Arc)>, masks: &[Option>]) -> Vec> { use crate::revolve::{Coverage, overlaps}; struct Run { surface: Option, bounds: Rect, faces: Vec>, cover: Vec, } let mut runs: Vec = vec![]; let mut last_run = vec![None; masks.len()]; // Past this many tests a face starts a run of its own, which never draws out of order. let mut budget = crate::revolve::MAX_OVERLAP_TESTS; for (surface, face) in faces { let Some(cover) = Coverage::of(&face) else { // A face with no outline and no box overlaps nothing. runs.push(Run { surface: None, bounds: Rect::ZERO, faces: vec![face], cover: vec![] }); continue; }; if masks.get(surface).is_none_or(Option::is_none) { runs.push(Run { surface: None, bounds: cover.bounds, faces: vec![face], cover: vec![cover] }); continue; } let mut clear = |r: &Run| { budget = budget.saturating_sub(1); if !overlaps(r.bounds, cover.bounds) { return budget > 0; } budget = budget.saturating_sub(r.cover.len()); budget > 0 && r.cover.iter().all(|c| !overlaps(c.bounds, cover.bounds) || !c.meets(&cover)) }; let joins = last_run.get(surface).copied().flatten().filter(|&i: &usize| runs.get(i + 1..).is_some_and(|later| later.iter().all(&mut clear))); match joins.and_then(|i| runs.get_mut(i)) { Some(run) => { run.bounds = run.bounds.union(cover.bounds); run.faces.push(face); run.cover.push(cover); } None => { if let Some(last) = last_run.get_mut(surface) { *last = Some(runs.len()); } runs.push(Run { surface: Some(surface), bounds: cover.bounds, faces: vec![face], cover: vec![cover] }); } } } runs.into_iter() .filter_map(|mut r| { let Some(mask) = r.surface.and_then(|s| masks.get(s)).cloned().flatten() else { return r.faces.pop() }; let mut group = Node::group(id, r.faces); group.extras_mut().mask = Some(mask); Some(Arc::new(group)) }) .collect() } fn geometry(path: &PathData, fx: &[Effect], ctx: &GeomContext) -> PathData { apply_geometry_with(fx, path, path.bounds().unwrap_or(Rect::ZERO), ctx) } /// `n` drawn with its Extrude & Bevel, Inflate or Rotate effect: a group of shaded faces keeping /// the object's id and transparency, the source path untouched. `None` without such an effect. /// On a group or layer the effect builds a solid from each path, compound path and type in it, /// all turned about one shared axis ([`members`]). pub fn solid_art(n: &Node) -> Option { solid_art_in(None, n) } /// [`solid_art`] with the symbols of `doc`: a symbol instance, a blend and a clipping group, alone /// or in a group, build from the art they show ([`resolve`]). `None` too when that art can't be /// resolved. pub fn solid_art_in(doc: Option<&Document>, n: &Node) -> Option { if !has_solid(n) { return None; } let n = &*resolve(doc, n, "").ok()?; if is_container(n) { return group_solid_art(doc, n); } let (path, rule) = profile(n)?; let ctx = GeomContext::of(n); let (sources, paints) = solid_paint_sources(n); let mut children = vec![]; let remaining: Vec; if let Some((index, fx)) = solid(&n.appearance.effects) { let path = geometry(&path, n.appearance.effects.get(..index)?, &ctx); let (shadow, surfaces) = art_for(doc, n, fx, &[Profile { path, rule, items: paints, opacity: 1.0, scopes: vec![] }])?; children.extend(shadow.into_iter().chain(surfaces)); // Later geometry effects act on the projected art as a whole. remaining = past_effect(&n.appearance.effects, index); } else { let path = geometry(&path, &n.appearance.effects, &ctx); remaining = crate::without_geometry(&n.appearance.effects); // The object's Transform effects, applied to the path above, transform the items' raster // effects too. let mut paints = paints; crate::raster::follow_paints(&mut paints, &n.appearance.effects); // Every item's shadow goes behind every item's art. let mut shadows = vec![]; for (source, item) in sources.into_iter().zip(&paints) { if let Some((index, fx)) = solid(item.effects()) { let p = geometry(&path, item.effects().get(..index)?, &ctx.item(source.unwrap_or(item))); let (shadow, surfaces) = art_for(doc, n, fx, &[Profile { path: p, rule, items: vec![item.clone()], opacity: 1.0, scopes: vec![] }])?; let later: Vec = item.effects().iter().skip(index + 1).filter(|e| !is_three_d(&e.id)).cloned().collect(); let with_later = |mut art: Arc| { Arc::make_mut(&mut art).appearance.effects = later.clone(); art }; shadows.extend(shadow.into_iter().map(with_later)); children.extend(surfaces.into_iter().map(with_later)); } else { let flat = Appearance { items: vec![item.clone()], ..Default::default() }; children.push(Arc::new(crate::group::shape_node(n.id, path.clone(), rule, flat))); } } children.splice(0..0, shadows); } let mut art = n.clone(); art.kind = NodeKind::Group { children, clip: false }; art.appearance = Appearance { effects: remaining, ..Default::default() }.into(); Some(art) } /// [`solid_art`] of group or layer `n`: its object-level 3D effect on its members together. The /// geometry effects before it reshape the members, those after it bend the result as a whole; the /// group's own fills and strokes are not drawn. `None` when the effect is only on one of the /// group's own fills or strokes, or when its members can't become solids. fn group_solid_art(doc: Option<&Document>, n: &Node) -> Option { let (index, fx) = solid(&n.appearance.effects)?; let mut shapes = members(n, "").ok()?; reshape_members(n, n.appearance.effects.get(..index)?, &mut shapes); let (shadow, surfaces) = art_for(doc, n, fx, &shapes)?; let children = shadow.into_iter().chain(surfaces).collect(); let remaining = past_effect(&n.appearance.effects, index); let mut art = n.clone(); art.kind = NodeKind::Group { children, clip: false }; art.appearance = Appearance { effects: remaining, ..Default::default() }.into(); Some(art) } /// Where the graphics of the 3D effect of `n` (on the object itself with `item` `None`, else on its /// fill or stroke `item`) are drawn: the bounds its solids are built with and the maps of their /// planar faces ([`graphics::GraphicFrame`]). `None` when `n` has no visible Extrude & Bevel or /// Rotate there, or its art can't be built. pub fn graphic_frame(doc: Option<&Document>, n: &Node, item: Option) -> Option { frame_of(doc, n, item, &solid) } /// [`graphic_frame`] of the 3D effect at `index` in that list, which must be a visible Extrude & /// Bevel, Rotate or Revolve. Revolve's frame is its unrolled side seen from the front, centered on /// the origin, with no face maps: it sizes a new graphic and places no handles. pub fn graphic_frame_at(doc: Option<&Document>, n: &Node, item: Option, index: usize) -> Option { frame_of(doc, n, item, &|fx: &[Effect]| fx.get(index).filter(|e| e.visible && is_three_d(&e.id)).map(|e| (index, e))) } /// Does a visible geometry effect come after the 3D effect at `index` in the effects of `n` (on the /// object itself with `item` `None`, else on its fill or stroke `item`)? Such an effect moves or /// bends the drawn art, graphics included, while [`graphic_frame_at`] places the graphics on the /// art before it. pub fn graphics_reshaped_after(n: &Node, item: Option, index: usize) -> bool { n.appearance.effects_at(item).and_then(|fx| fx.get(index + 1..)).is_some_and(crate::has_geometry) } /// Finds a 3D effect in a list of effects, with its index there. type Pick<'p> = dyn for<'e> Fn(&'e [Effect]) -> Option<(usize, &'e Effect)> + 'p; /// [`graphic_frame`] of the 3D effect `pick` finds in the effects of `n` or its `item`. fn frame_of(doc: Option<&Document>, n: &Node, item: Option, pick: &Pick<'_>) -> Option { let n = &*resolve(doc, n, "").ok()?; let (fx, shapes) = if is_container(n) { let (index, fx) = pick(&n.appearance.effects).filter(|_| item.is_none())?; let mut shapes = members(n, "").ok()?; reshape_members(n, n.appearance.effects.get(..index)?, &mut shapes); (fx, shapes) } else { let (path, rule) = profile(n)?; let ctx = GeomContext::of(n); match item { None => { let (index, fx) = pick(&n.appearance.effects)?; let path = geometry(&path, n.appearance.effects.get(..index)?, &ctx); (fx, vec![Profile { path, rule, items: solid_paints(n), opacity: 1.0, scopes: vec![] }]) } Some(k) => { let it = n.appearance.items.get(k)?; let (index, fx) = pick(it.effects())?; let path = geometry(&geometry(&path, &n.appearance.effects, &ctx), it.effects().get(..index)?, &ctx.item(it)); (fx, vec![Profile { path, rule, items: vec![it.clone()], opacity: 1.0, scopes: vec![] }]) } } }; if !takes_graphics(&fx.id) { return None; } let p = crate::merged_params(&fx.id, &fx.params); let b = union_bounds(&shapes)?; if fx.id == crate::REVOLVE { // Revolve's graphics lie on its unrolled side (in a group, the side of the member with the // longest profile): the frame is the part of it seen from the front, with no planar face // to place a handle on. let options = crate::revolve::revolve_options(&p); let (w, h) = shapes .iter() .filter(|s| crate::revolve::surface_item(&s.items).is_some()) .filter_map(|s| vectorcraft_three_d::revolve_surface_size(&s.path, b, options)) .fold((0.0f64, 0.0f64), |best, size| if size.1 > best.1 { size } else { best }); if w <= 0.0 || h <= 0.0 { return None; } return Some(graphics::GraphicFrame::new(Rect::new(-w / 2.0, -h / 2.0, w / 2.0, h / 2.0), None, None)); } let view = view_options(&p); if fx.id == ROTATE { let plane = vectorcraft_three_d::plane_face_map(b, view); return Some(graphics::GraphicFrame::new(b, plane, None)); } let (_, bounds) = solid_parts(&shapes, b); let options = extrude_options(&p); let map = |face| vectorcraft_three_d::extrude_face_map(bounds, options, view, face); Some(graphics::GraphicFrame::new(bounds, map(PlanarFace::Front), map(PlanarFace::Back))) } /// The bounds of the art symbol `name` of `doc` draws as a graphic, in the symbol's coordinates. pub fn graphic_bounds(doc: &Document, name: &str) -> Option { graphics::art_bounds(doc, name) } /// `effects` without the 3D effect at `index` and the geometry effects before it, which shape the /// art it projects. Each raster effect before it follows the Transform effects among those /// ([`crate::without_geometry`]), unless a Transform effect after it makes copies or moves at /// random ([`crate::raster::holds_back`]); the effects after it stay as they are. pub(crate) fn past_effect(effects: &[Effect], index: usize) -> Vec { let (before, after) = effects.split_at(index.min(effects.len())); let after = after.get(1..).unwrap_or_default(); let kept: Vec = if after.iter().any(crate::raster::holds_back) { before.iter().filter(|e| !is_geometry(&e.id)).cloned().collect() } else { crate::without_geometry(before) }; kept.into_iter().chain(after.iter().cloned()).collect() } /// One solid of a 3D object as a mesh, with the color it is painted. #[derive(Clone, Debug, PartialEq)] pub struct SolidMesh { pub mesh: Mesh, /// The paint's display color (sRGB, 0..1) and its opacity: a gradient's stops averaged, gray /// for a pattern. pub color: [f32; 4], } /// The color a mesh of `paint` at `opacity` takes ([`SolidMesh::color`]). pub(crate) fn mesh_color(paint: &Paint, opacity: f32) -> [f32; 4] { let (rgb, alpha) = match paint { Paint::Solid { color, .. } => (color.to_rgb(), 1.0), Paint::Gradient(g) if !g.gradient.stops.is_empty() => { let n = g.gradient.stops.len() as f32; let mut sum = [0.0f32; 4]; for s in &g.gradient.stops { let [r, gr, b] = s.color.to_rgb(); sum = [sum[0] + r, sum[1] + gr, sum[2] + b, sum[3] + s.opacity]; } ([sum[0] / n, sum[1] / n, sum[2] / n], sum[3] / n) } _ => ([0.5; 3], 1.0), }; let unit = |v: f32| if v.is_finite() { v.clamp(0.0, 1.0) } else { 0.0 }; [unit(rgb[0]), unit(rgb[1]), unit(rgb[2]), unit(alpha * opacity)] } /// Add `mesh` to `out`, counting its triangles into `total`, or an error when that passes `limit`. pub(crate) fn keep_mesh(out: &mut Vec, total: &mut usize, mesh: SolidMesh, limit: usize) -> Result<(), String> { *total = total.saturating_add(mesh.mesh.triangles.len()); if *total > limit { return Err("The 3D object is too complex to export".into()); } out.push(mesh); Ok(()) } /// The solids effect `fx` builds from `shapes`, as [`art_for`] draws them, as meshes: Rotate turns /// every fill and stroke; Extrude & Bevel and Inflate build one from each shape's top fill and one /// from the outline of each stroke. A stroke whose solid is past the limits is left out. Each mesh /// is counted against `limit` ([`keep_mesh`]) before the next is built. fn meshes_for(fx: &Effect, shapes: &[Profile], total: &mut usize, limit: usize) -> Result, String> { let label = crate::effect_info(&fx.id).map_or("This effect", |e| e.label.trim_end_matches('…')); let b = union_bounds(shapes).ok_or_else(|| format!("{label} requires a shape with at least two anchors"))?; let p = crate::merged_params(&fx.id, &fx.params); let view = view_options(&p); let mut out = vec![]; let mut keep = |out: &mut Vec, mesh: Mesh, color: [f32; 4]| keep_mesh(out, total, SolidMesh { mesh, color }, limit); if is_plane(&fx.id) { for s in shapes { for item in &s.items { let (paint, opacity, _) = paint_of(item, s.opacity); let (area, rule) = region(&s.path, s.rule, item); keep(&mut out, vectorcraft_three_d::plane_mesh(&area, rule, b, view)?, mesh_color(&paint, opacity))?; } } return Ok(out); } let (parts, bounds) = solid_parts(shapes, b); // Inflate lays out every puff at once (they share one eye). Each Inflate and Extrude & Bevel // solid is built once, as the loop reaches it: its facets decide whether the art draws it, as // [`built_solids`] does, and its faces before projection make its mesh. let mut inflated = (fx.id == INFLATE).then(|| { let shapes: Vec<(&PathData, FillRule)> = parts.iter().map(|(_, _, area, rule, _, _)| (area, *rule)).collect(); vectorcraft_three_d::inflate_meshed(&shapes, bounds, inflate_options(&p), view) }); let extrude = if fx.id == CLASSIC_EXTRUDE { classic_extrude_options(&p) } else { extrude_options(&p) }; let mut kept = 0usize; for (item, member, area, rule, _, _) in &parts { let item: &AppearanceItem = item; #[cfg(test)] SOLIDS_BUILT.with(|n| n.set(n.get() + 1)); let built = match inflated.as_mut() { Some(each) => each.next().unwrap_or_else(|| Ok(MeshedSolid::default())), None => vectorcraft_three_d::extrude_meshed(area, *rule, bounds, extrude, view), }; // A stroke the art leaves out is left out of the meshes too. The faces of the solids kept // count together against the object's limit. let solid = match built { Ok(solid) => solid, Err(_) if matches!(item, AppearanceItem::Stroke(_)) => continue, Err(e) => return Err(e), }; kept = kept.saturating_add(solid.facets.len()); if kept > MAX_OBJECT_FACES { return Err(vectorcraft_three_d::TOO_COMPLEX_SOLID.to_string()); } match solid.mesh() { Ok(mesh) => { let (paint, opacity, _) = paint_of(item, *member); keep(&mut out, mesh, mesh_color(&paint, opacity))?; } Err(_) if matches!(item, AppearanceItem::Stroke(_)) => {} Err(e) => return Err(e), } } Ok(out) } /// The solids `n`'s Extrude & Bevel, Inflate, Rotate or Revolve effect builds, as meshes with the /// colors they are painted ([`SolidMesh`]), faces turned away from the viewer included; meshes /// with no triangles are left out. On a group or layer, the effect's solids of its members /// ([`members`]). The object's opacity multiplies every color's. An error when `n` carries no /// such effect, its solids can't be built, none has a triangle, or together they have more than /// [`MAX_MESH_TRIANGLES`]. pub fn three_d_meshes(n: &Node) -> Result, String> { three_d_meshes_in(None, n) } /// [`three_d_meshes`] with the symbols of `doc`: a symbol instance, a blend and a clipping group /// build from the art they show ([`resolve`]). pub fn three_d_meshes_in(doc: Option<&Document>, n: &Node) -> Result, String> { meshes_within(doc, n, &mut 0, MAX_MESH_TRIANGLES) } /// The meshes of every object in `nodes` ([`three_d_meshes`]), in order, as one 3D asset exports /// them: the objects share one budget of [`MAX_MESH_TRIANGLES`]. pub fn three_d_meshes_of<'a>(nodes: impl IntoIterator) -> Result, String> { three_d_meshes_of_in(None, nodes) } /// [`three_d_meshes_of`] with the symbols of `doc` ([`three_d_meshes_in`]). pub fn three_d_meshes_of_in<'a>(doc: Option<&Document>, nodes: impl IntoIterator) -> Result, String> { meshes_of_within(doc, nodes, MAX_MESH_TRIANGLES) } /// [`three_d_meshes_of_in`] with a budget of `limit` triangles. fn meshes_of_within<'a>(doc: Option<&Document>, nodes: impl IntoIterator, limit: usize) -> Result, String> { let mut total = 0usize; let mut out = vec![]; for n in nodes { out.extend(meshes_within(doc, n, &mut total, limit)?); } Ok(out) } /// [`three_d_meshes_in`], with the triangles of every solid added to `total` as it is built and an /// error as soon as `total` passes `limit`. fn meshes_within(doc: Option<&Document>, n: &Node, total: &mut usize, limit: usize) -> Result, String> { if !crate::has_revolve(n) && !has_solid(n) { return Err("the object has no 3D effect (Extrude & Bevel, Revolve, Inflate or Rotate)".into()); } let label = n.appearance.effects.iter().find(|e| e.visible && is_three_d(&e.id)).map_or("This effect", |e| label_of(&e.id)); let n = &*resolve(doc, n, label)?; let meshes = if crate::has_revolve(n) { crate::revolve::revolve_meshes(n, total, limit)? } else if !has_solid(n) { return Err("the object has no 3D effect (Extrude & Bevel, Revolve, Inflate or Rotate)".into()); } else if is_container(n) { let (index, fx) = solid(&n.appearance.effects).ok_or("a 3D effect on a group's fill or stroke draws nothing to export")?; let label = crate::effect_info(&fx.id).map_or("This effect", |e| e.label.trim_end_matches('…')); let mut shapes = members(n, label)?; reshape_members(n, n.appearance.effects.get(..index).unwrap_or_default(), &mut shapes); meshes_for(fx, &shapes, total, limit)? } else { let (path, rule) = object_profile(n, label)?; let ctx = GeomContext::of(n); let (sources, paints) = solid_paint_sources(n); if let Some((index, fx)) = solid(&n.appearance.effects) { let path = geometry(&path, n.appearance.effects.get(..index).unwrap_or_default(), &ctx); meshes_for(fx, &[Profile { path, rule, items: paints, opacity: 1.0, scopes: vec![] }], total, limit)? } else { let path = geometry(&path, &n.appearance.effects, &ctx); let mut out = vec![]; for (source, item) in sources.into_iter().zip(&paints) { if let Some((index, fx)) = solid(item.effects()) { let p = geometry(&path, item.effects().get(..index).unwrap_or_default(), &ctx.item(source.unwrap_or(item))); out.extend(meshes_for(fx, &[Profile { path: p, rule, items: vec![item.clone()], opacity: 1.0, scopes: vec![] }], total, limit)?); } } out } }; let meshes: Vec = meshes .into_iter() .filter(|m| !m.mesh.is_empty()) .map(|mut m| { m.color[3] *= n.opacity.clamp(0.0, 1.0); m }) .collect(); if meshes.is_empty() { return Err("its 3D effect builds no solid".into()); } Ok(meshes) } #[cfg(test)] mod tests; #[cfg(test)] mod tests_mesh; #[cfg(test)] mod tests_sources; #[cfg(test)] mod tests_shadow; #[cfg(test)] mod tests_revolve_order;