GitCorner

Code

ossartcraftvectorcraft🌐
2bc41aeb8602
//! 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::map_art::{
    MAP_ART, MAP_ART_NOT_TAKEN, MAP_INVISIBLE, MAP_SHADE, MAX_MAP_SURFACE, MAX_MAPS, SurfaceMap, surface_maps, takes_map_art, with_surface_map,
};
use graphics::map_art::{MapArt, MapBudget, SolidLayout};
pub use graphics::{
    GRAPHICS, GraphicFrame, MAX_GRAPHICS, MappedGraphic, MeshGraphics, graphic_symbols, mapped_graphics, mesh_graphics_art, 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,
    fitting as graphic_fitting_scale, rename_appearance_graphic_symbol,
};
pub use vectorcraft_three_d::SurfaceKind;

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 and on Extrude & Bevel's side are dropped.
    if (to == ROTATE || to == crate::REVOLVE)
        && let Some(Value::Array(list)) = out.get_mut(GRAPHICS)
    {
        list.retain(|g| {
            let face = g.get("face").and_then(Value::as_str);
            face != Some(PlanarFace::Back.id()) && face != Some(PlanarFace::Side.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())
}

/// Does `n` carry a 3D effect that [`three_d_meshes`] builds solids from: a visible Revolve, or
/// else a visible Extrude & Bevel, Inflate or Rotate effect, which on a group or layer must be on
/// the object itself (one on a group's fill or stroke draws nothing to export)? It does not build
/// the solids, so [`three_d_meshes`] can still refuse an object it passes.
pub fn exports_three_d(n: &Node) -> bool {
    let container = is_container(n);
    if crate::has_revolve(n) {
        !container || n.appearance.effects.iter().any(|e| e.visible && crate::is_revolve(&e.id))
    } else if container {
        solid(&n.appearance.effects).is_some()
    } else {
        has_solid(n)
    }
}

/// 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,
        map_surfaces: false,
        map_surface: 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<AppearanceItem> {
    let own: Vec<AppearanceItem> = 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<Option<&AppearanceItem>>, Vec<AppearanceItem>) {
    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<Vec<Facet>, 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`] of Extrude & Bevel with parameters `p`, with the pieces of the side of its longest
/// contour carrying where they lie on it unrolled ([`Facet::surface`]), for its side's graphics.
fn side_facets(path: &PathData, rule: FillRule, bounds: Rect, p: &Value) -> Result<Vec<Facet>, String> {
    #[cfg(test)]
    SOLID_GEOMETRY_BUILT.with(|n| n.set(n.get() + 1));
    vectorcraft_three_d::extrude(path, rule, bounds, Extrude { map_surface: true, ..extrude_options(p) }, view_options(p))
}

/// [`side_facets`], and with `cast` the faces the solid's shadow is cast from, from the same build
/// ([`facets_and_faces`]).
fn side_facets_and_faces(path: &PathData, rule: FillRule, bounds: Rect, p: &Value, cast: bool) -> Result<CastingSolid, String> {
    if !cast {
        return side_facets(path, rule, bounds, p).map(|f| (f, None));
    }
    #[cfg(test)]
    SOLID_GEOMETRY_BUILT.with(|n| n.set(n.get() + 1));
    let options = Extrude { map_surface: true, ..extrude_options(p) };
    vectorcraft_three_d::extrude_shadowed(path, rule, bounds, options, view_options(p)).map(|(f, faces)| (f, Some(faces)))
}

/// The part of `parts` ([`solid_parts`]) whose solid takes the graphics on Extrude & Bevel's side,
/// with parameters `p` and built about `bounds`: the first of those with the longest outline
/// ([`vectorcraft_three_d::extrude_side_size`]). `None` when the effect `id` is not Extrude & Bevel
/// or has no graphic on its side, or when no part has a side.
fn side_carrier(id: &str, p: &Value, parts: &[Part<'_>], bounds: Rect) -> Option<usize> {
    if id != EXTRUDE || !mapped_graphics(p).iter().any(|g| g.face == PlanarFace::Side) {
        return None;
    }
    let options = extrude_options(p);
    parts
        .iter()
        .enumerate()
        .filter_map(|(k, (_, _, area, rule, _, _))| vectorcraft_three_d::extrude_side_size(area, *rule, bounds, options).map(|(w, ..)| (k, w)))
        .fold(None, |best: Option<(usize, f64)>, (k, w)| if best.is_some_and(|(_, top)| top >= w) { best } else { Some((k, w)) })
        .map(|(k, _)| k)
}

/// The size of Extrude & Bevel's side unrolled for the graphics on it: the side of the part of
/// `shapes` that [`side_carrier`] picks, with parameters `p`, as wide as the part of it about x = 0
/// that does not reach its cut and as tall as the length across its bevels and walls.
fn side_size(p: &Value, shapes: &[Profile]) -> Option<(f64, f64)> {
    let (parts, bounds) = solid_parts(shapes, union_bounds(shapes)?);
    let options = extrude_options(p);
    parts
        .iter()
        .filter_map(|(_, _, area, rule, _, _)| vectorcraft_three_d::extrude_side_size(area, *rule, bounds, options))
        .fold(None, |best: Option<(f64, f64, f64)>, size| if best.is_some_and(|top| top.0 >= size.0) { best } else { Some(size) })
        .map(|(_, height, span)| (span, height))
}

/// [`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<Facet>, Option<SolidFaces>), 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<usize>, Option<usize>)) -> 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_side_graphics(doc, n, 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_side_graphics(doc, n, id, p, &shapes)
}

/// Does 3D effect `id` with parameters `p` cast a shadow: is it Extrude & Bevel, Inflate or Rotate
/// with Shadows on, shaded? In wireframe mode no shadow is drawn, and none is checked.
fn casts_shadow(id: &str, p: &Value) -> bool {
    !is_classic_three_d(id) && shadow::options(p).is_some() && !wireframe::wireframe_params(id, p)
}

/// Does `item` of a shape with opacity `member` paint anything, and so cast a shadow?
fn visible(item: &AppearanceItem, member: f32) -> bool {
    paint_of(item, member).1 > 0.0
}

/// An error when the graphics on the side of Extrude & Bevel `id` with parameters `p`, with the
/// symbols of `doc`, are past their limits on the side of the solid of `shapes` that takes them
/// ([`side_carrier`]): their art, or the parts they draw on its pieces
/// ([`graphics::surface_parts`]), or when the object `n`'s surfaces can't be built at all. They are
/// built as the art builds them ([`surfaces_with`]), so its pieces are the ones the art draws, cuts
/// included. On Extrude & Bevel (Classic), the art Map Art places on walls and bevels must also fit
/// ([`graphics::validate_unrolled_symbols`]). Without `doc` nothing is drawn, and nothing is checked.
fn check_side_graphics(doc: Option<&Document>, n: &Node, id: &str, p: &Value, shapes: &[Profile]) -> Result<(), String> {
    let Some(doc) = doc else { return Ok(()) };
    let Some(b) = union_bounds(shapes) else { return Ok(()) };
    let (parts, bounds) = solid_parts(shapes, b);
    // Map Art unrolls its art onto walls and bevels; the caps draw it as it is.
    if id == CLASSIC_EXTRUDE && !surface_maps(p).is_empty() {
        let options = vectorcraft_three_d::Extrude { map_surfaces: true, ..classic_extrude_options(p) };
        let unrolled: Vec<Option<Point>> = parts
            .iter()
            .flat_map(|(_, _, area, rule, _, _)| vectorcraft_three_d::extrude_surfaces(area, *rule, bounds, options).unwrap_or_default())
            .map(|s| (!matches!(s.kind, SurfaceKind::End(_))).then(|| graphics::map_art::flat_center(&s)))
            .collect();
        graphics::validate_unrolled_symbols(doc, p, &|surface| surface.checked_sub(1).and_then(|k| unrolled.get(k).copied().flatten()))?;
    }
    if side_carrier(id, p, &parts, bounds).is_none() {
        return Ok(());
    }
    graphics::validate_surface_symbols(doc, p, PlanarFace::Side)?;
    let fx = Effect { id: id.into(), params: p.clone(), visible: true };
    let mut dropped = false;
    // Art that can't be built draws the source path, without the side's graphics.
    let built = surfaces_with(Some(doc), n, &fx, shapes, false, &mut dropped);
    if dropped || built.is_none() {
        return Err("The graphics are too complex: simplify the symbols' art".into());
    }
    Ok(())
}

/// 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: for Rotate
/// every shape's, except with its shadow cast that of a shape with a visible fill, whose plane is
/// the fill's; 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> {
    let cast = casts_shadow(id, p);
    let fill = |s: &Profile| s.items.iter().any(|i| matches!(i, AppearanceItem::Fill(_)) && (!is_plane(id) || visible(i, s.opacity)));
    shapes.iter().filter(|s| if is_plane(id) { !(cast && fill(s)) } else { !fill(s) }).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`]), and with its shadow cast, does
/// the shadow fit? The shadow is cast from the faces those same builds kept ([`cast_built`]), as
/// [`art_for`] casts it: Extrude & Bevel and Inflate build each solid once, and Rotate builds the
/// plane of each visible fill and stroke once. Rotate's planes are not counted, and without its
/// shadow Rotate builds no plane here.
fn check_solids(id: &str, p: &Value, shapes: &[Profile]) -> Result<(), String> {
    let Some(b) = union_bounds(shapes) else { return Ok(()) };
    let cast = casts_shadow(id, p);
    if is_plane(id) {
        if !cast {
            return Ok(());
        }
        let mut built = vec![];
        for s in shapes {
            for item in &s.items {
                if !visible(item, s.opacity) {
                    built.push(None);
                    continue;
                }
                let (area, rule) = region(&s.path, s.rule, item);
                #[cfg(test)]
                SOLIDS_BUILT.with(|n| n.set(n.get() + 1));
                built.push(facets_and_faces(ROTATE, &area, rule, b, p, true)?.1);
            }
        }
        return cast_built(id, p, shapes, built).map(|_| ());
    }
    let (parts, bounds) = solid_parts(shapes, b);
    if !cast {
        return built_solids(id, p, &parts, bounds, MAX_OBJECT_FACES).try_for_each(|r| r.map(|_| ()));
    }
    let built = built_solids_cast(id, p, &parts, bounds, MAX_OBJECT_FACES, true, None)
        .map(|r| r.map(|solid| solid.and_then(|(_, faces)| faces)))
        .collect::<Result<Vec<_>, String>>()?;
    cast_built(id, p, shapes, built).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<Arc<OpacityMask>>,
}

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<Self> {
        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<Arc<Node>>) -> 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<Node>)>) -> Vec<Arc<Node>> {
    let masks: Vec<(Vec<Scope>, Arc<Node>)> = 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<AppearanceItem>,
    pub(crate) opacity: f32,
    pub(crate) scopes: Vec<Scope>,
}

/// 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<Rect> {
    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<Vec<Profile>, String> {
    struct Walk<'a> {
        label: &'a str,
        out: Vec<Profile>,
        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>, 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>, 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. Under colored lights a gradient with transparent stops is drawn
/// opaque under one mask of its transparency, placed once on all the facets when it has no
/// placement of its own ([`crate::lighting::opaque_surface_paint`]).
fn surface(n: &Node, facets: Vec<Facet>, 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_surface_paint(paint, || facets_bounds(&facets)) } 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
}

/// `surface`, a plain group of one face for each facet ([`surface`]), with each face followed by
/// the parts of the side's graphics that `parts` holds for its facet ([`graphics::surface_parts`]):
/// a face with parts becomes a group of the face and its parts, so nearer faces drawn after it
/// cover them too. `surface` is returned as it is when no facet has a part or it is not such a group.
fn with_side_parts(id: NodeId, mut surface: Node, parts: Vec<Vec<Arc<Node>>>) -> Node {
    if parts.iter().all(Vec::is_empty) {
        return surface;
    }
    let NodeKind::Group { children, clip: false } = &mut surface.kind else { return surface };
    if children.len() != parts.len() {
        return surface;
    }
    for (child, extra) in children.iter_mut().zip(parts) {
        if extra.is_empty() {
            continue;
        }
        let mut list = Vec::with_capacity(extra.len() + 1);
        list.push(child.clone());
        list.extend(extra);
        *child = Arc::new(Node::group(id, list));
    }
    surface
}

/// The bounds of every facet of `facets` together (`Rect::ZERO` when none has any).
pub(crate) fn facets_bounds(facets: &[Facet]) -> Rect {
    facets.iter().filter_map(|f| f.path().bounds()).reduce(|a, c| a.union(c)).unwrap_or(Rect::ZERO)
}

/// 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<Part<'_>>, Rect) {
    let parts: Vec<Part> = 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<usize> = 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. The solids built to cast a shadow
    /// ([`cast_shadow`]) count too.
    static SOLID_GEOMETRY_BUILT: std::cell::Cell<usize> = 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<Item = Result<Option<Vec<Facet>>, String>> + 'a {
    built_solids_cast(id, p, parts, bounds, limit, false, None).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<Facet>, Option<SolidFaces>);

/// The surfaces of an object's solids, and the faces each solid kept for its shadow
/// ([`surfaces_for`]).
type SurfacesAndFaces = (Vec<Arc<Node>>, Vec<Option<SolidFaces>>);

/// [`built_solids`], and with `cast` for Extrude & Bevel or Inflate each solid's faces its shadow
/// is cast from, from the same build ([`SolidFaces`]). The solid of part `side`, when there is one,
/// is built with the pieces of its side carrying where they lie on it unrolled, for the graphics
/// on Extrude & Bevel's side ([`side_carrier`]).
fn built_solids_cast<'a>(
    id: &'a str,
    p: &'a Value,
    parts: &'a [Part<'a>],
    bounds: Rect,
    limit: usize,
    cast: bool,
    side: Option<usize>,
) -> impl Iterator<Item = Result<Option<CastingSolid>, 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<dyn Iterator<Item = Result<CastingSolid, String>>> {
        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().enumerate().map_while(move |(k, (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 if side == Some(k) => side_facets_and_faces(area, *rule, bounds, p, cast),
            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<Point>,
    plane: Option<DepthPlane>,
}

/// 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<Item = &'a AppearanceItem>, 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<Facet>)], 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<usize> = (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<Facet>, 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<f64> = 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::<Option<_>>()?,
    };
    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));
        // A piece keeps where the whole face lies on the side: the parts of the side's graphics
        // drawn on it are cut to its own outline ([`graphics::SurfaceFace::curved`]).
        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<PathData> {
    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<Point> {
    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<usize>) -> Vec<usize> {
    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<usize>> = 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<usize> = (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<usize>> = 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<Reverse<(usize, usize)>> =
        (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<usize> = 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<bool> {
    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<f64> {
    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<Point> {
    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<Point> {
    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<usize> {
    // 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<&Placed>> = 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<usize> = (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<Item = (&'a [Point], Option<DepthPlane>, f64)>) -> Vec<usize> {
    let placed: Vec<Placed> = 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<Arc<Node>>, Vec<Arc<Node>>);

/// 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<ShadowAndSurfaces> {
    // 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 = casts_shadow(&fx.id, &p);
    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<Vec<Arc<Node>>, 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<Option<Cast<'a>>, 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 fill or stroke (or member) that is fully transparent, or whose
    // opacity is not a finite number, casts nothing and does not place the plane ([`shadow::Ink::casts`]).
    let mut cast: Vec<shadow::Cast> = 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).casts()) {
                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<shadow::Ink> = 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<Result<std::ops::Range<usize>, String>> = if id == INFLATE {
            let shapes: Vec<(&PathData, FillRule)> = parts.iter().map(|(_, _, area, rule, _, _)| (area, *rule)).collect();
            let casts: Vec<bool> = inks.iter().map(|i| i.casts()).collect();
            #[cfg(test)]
            SOLIDS_BUILT.with(|n| n.set(n.get() + shapes.len()));
            #[cfg(test)]
            SOLID_GEOMETRY_BUILT.with(|n| n.set(n.get() + casts.iter().filter(|c| **c).count()));
            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.casts())));
                #[cfg(test)]
                SOLID_GEOMETRY_BUILT.with(|n| n.set(n.get() + usize::from(ink.casts())));
                added.push(if ink.casts() { 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.casts() {
                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`]). No solid is built here: an entry with no faces
/// (a stroke's solid left out of the art, past its own limits) casts nothing, as it draws nothing.
/// Only `built` of another length than the solids is cast as [`cast_shadow`] casts it.
fn cast_built<'a>(id: &str, p: &Value, shapes: &'a [Profile], built: Vec<Option<SolidFaces>>) -> Result<Option<Cast<'a>>, 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 mut caster = vectorcraft_three_d::ShadowCaster::new();
    let mut cast: Vec<shadow::Cast> = 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.casts() {
                continue;
            }
            let Some(kept) = kept else { continue };
            cast.push((s.scopes.as_slice(), ink, caster.add_solid(kept)?));
        }
        return Ok(Some((caster, settings, cast)));
    }
    let (parts, _) = solid_parts(shapes, b);
    if parts.len() != built.len() {
        return cast_shadow(id, p, shapes);
    }
    for ((item, member, _, _, scopes, _), kept) in parts.iter().zip(built) {
        let ink = ink(item, *member);
        // A fully transparent solid, or a stroke's solid left out of the art, casts nothing.
        let Some(kept) = kept.filter(|_| ink.casts()) else { 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 caster.add_solid(kept) {
            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<shadow::Cast<'a>>);

/// 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<Node>)> {
    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<Facet>,
    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<Node>);

/// 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<Placement> {
    let mut groups: Vec<Vec<&Filled>> = 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<Placed>, Node, &'s [Scope], Vec<Option<PlanarFace>>);

/// [`with_graphics`] of built surfaces, each drawn whole.
fn whole_surfaces<'s>(surfaces: Vec<BuiltSurface<'s>>, arts: &[Placement]) -> Vec<(&'s [Scope], Arc<Node>)> {
    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<Node>)>, first: usize, arts: &[Placement]) -> Vec<(&'s [Scope], Arc<Node>)> {
    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<Item = &Facet> {
    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<SurfacesAndFaces> {
    surfaces_with(doc, n, fx, shapes, cast, &mut false)
}

/// [`surfaces_for`], setting `side_dropped` when the graphics on Extrude & Bevel's side are past
/// their limits on the pieces drawn, and the solid that takes them draws without them.
fn surfaces_with(doc: Option<&Document>, n: &Node, fx: &Effect, shapes: &[Profile], cast: bool, side_dropped: &mut bool) -> Option<SurfacesAndFaces> {
    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<Facet> = 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, None, false).0
                } 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);
    // The graphics on Extrude & Bevel's side go once, on the side of the solid with the longest
    // outline, whose pieces are built carrying where they lie on it.
    let carrier = if graphics_on { side_carrier(&fx.id, &p, &parts, bounds) } else { None };
    let mut solids = vec![];
    let mut built = vec![];
    // With mapped art, each solid's place among the object's numbered surfaces: the surfaces are
    // counted through the parts in order, those of a part whose solid is left out too.
    let map_art = MapArt::of(doc, &fx.id, &p).filter(|_| fx.id == CLASSIC_EXTRUDE);
    let mut layouts: Vec<SolidLayout> = vec![];
    let mut surfaces_before = 0usize;
    let made = built_solids_cast(&fx.id, &p, &parts, bounds, MAX_OBJECT_FACES, cast, carrier);
    for (k, ((item, opacity, area, rule, scopes, member), f)) in parts.iter().zip(made).enumerate() {
        let item: &AppearanceItem = item;
        let layout = map_art.as_ref().map(|_| {
            let options = classic_extrude_options(&p);
            let surfaces = vectorcraft_three_d::extrude_surfaces(area, *rule, bounds, options).unwrap_or_default();
            let first = surfaces_before;
            surfaces_before += surfaces.len();
            SolidLayout { first, surfaces, ends: Some((bounds, options, view_options(&p))) }
        });
        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));
                layouts.extend(layout);
                built.push(faces);
            }
            // A stroke's outline past the limits is left out; the fill's solid still draws, and
            // the side's graphics on that outline are not drawn.
            Ok(None) => {
                built.push(None);
                *side_dropped |= carrier == Some(k);
            }
            // 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<bool> = (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<bool> =
        (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<usize> = 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<Facet>)> = 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<Filled> = solids
            .iter()
            .enumerate()
            .filter_map(|(at, (item, member, _, f, shape))| {
                let caps: Vec<Facet> = 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::<usize>() <= MAX_FACE_COMPOSITES;
    let members: Vec<usize> = solids.iter().map(|s| s.4).collect();
    // The classic surfaces of the solids, with mapped art when the effect has maps. When the art of
    // any solid is past the limits the object's maps share, every solid draws without mapped art.
    let mut classic_arts = if classic {
        let draw = |with_art: bool, copies: &mut usize| {
            let mut budget = MapBudget::default();
            let mut dropped = false;
            let mut arts = Vec::with_capacity(solids.len());
            for (k, (item, member, _, f, _)) in solids.iter().enumerate() {
                let (paint, opacity, blend) = paint_of(item, *member);
                let mapped = map_art.as_ref().filter(|_| with_art).zip(layouts.get(k)).map(|(art, layout)| classic::Mapped {
                    art,
                    layout,
                    budget: &mut budget,
                    copies: &mut *copies,
                });
                let (art, _, left_out) = classic::surface(n, f, &paint, (opacity, blend), &p, mapped, false);
                dropped |= left_out;
                arts.push(art);
            }
            (arts, dropped)
        };
        let mut used = paint_bytes;
        let (arts, dropped) = draw(map_art.is_some(), &mut used);
        if dropped { draw(false, &mut paint_bytes).0 } else { arts }
    } else {
        vec![]
    }
    .into_iter();
    // Which surfaces lie over an underlay of their facets, in one order or whole
    // ([`in_one_order`], [`underlaid_surface`]).
    let seals: Vec<bool> = solids.iter().map(|(.., f, _)| underlaid(f, colored)).collect();
    let seal = |range: std::ops::Range<usize>| seals.get(range).is_some_and(|s| s.iter().any(|s| *s));
    let side_graphics = carrier.map(|_| mapped_graphics(&p)).unwrap_or_default();
    // The paint copies of the side's graphics, apart from those of the surfaces, as on Revolve.
    let mut graphic_copies = 0usize;
    let surfaces: Vec<BuiltSurface> = solids
        .into_iter()
        .map(|(item, member, scopes, f, shape)| {
            let paints = Paints::of(item, closed(shape));
            let depths: Vec<Placed> = 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);
            // The carrier's pieces draw the parts of the side's graphics that fall on them; past
            // the graphics' limits the solid draws without them.
            let parts = if side_graphics.is_empty() || !f.iter().any(|f| f.surface.is_some()) {
                vec![]
            } else {
                let shade = |f: &Facet, c: vectorcraft_doc::color::Color| Paint::solid(crate::lighting::shade(c, f.illumination));
                let parts = graphics::surface_parts(doc, n.id, (&side_graphics, PlanarFace::Side), &f, &shade, &mut graphic_copies);
                *side_dropped |= parts.is_none();
                parts.unwrap_or_default()
            };
            let drawn = parts.iter().any(|p| !p.is_empty());
            let art = if classic {
                classic_arts.next().unwrap_or_else(|| Node::group(n.id, vec![]))
            } else {
                let faces = drawn || (split && shared.get(shape).copied().unwrap_or(false));
                with_side_parts(n.id, surface(n, f, &paint, opacity, blend, colored, faces), parts)
            };
            (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<BuiltSurface<'_>>, first: usize, arts: &[Placement], sealed: bool, seals: &[bool]) -> Vec<Arc<Node>> {
    let masks: Vec<Option<Box<OpacityMask>>> = 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<Option<usize>> = 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<Node>)> = 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<Node>)>, seal: impl Fn(usize) -> bool) -> Vec<(usize, Arc<Node>)> {
    let mut out = Vec::with_capacity(faces.len());
    let mut run: Vec<Arc<Node>> = 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<Node>)>, masks: &[Option<Box<OpacityMask>>]) -> Vec<Arc<Node>> {
    use crate::revolve::{Coverage, overlaps};
    struct Run {
        surface: Option<usize>,
        bounds: Rect,
        faces: Vec<Arc<Node>>,
        cover: Vec<Coverage>,
    }
    let mut runs: Vec<Run> = 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<Node> {
    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<Node> {
    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<Effect>;
    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<Effect> = item.effects().iter().skip(index + 1).filter(|e| !is_three_d(&e.id)).cloned().collect();
                let with_later = |mut art: Arc<Node>| {
                    Arc::make_mut(&mut art).appearance.effects = later.clone();
                    art
                };
                // A shadow keeps its own blur (the light's Softness) below the later effects.
                shadows.extend(shadow.into_iter().map(|mut art| {
                    Arc::make_mut(&mut art).appearance.effects.extend(later.iter().cloned());
                    art
                }));
                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<Node> {
    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<usize>) -> Option<graphics::GraphicFrame> {
    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<usize>, index: usize) -> Option<graphics::GraphicFrame> {
    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<usize>, 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;

/// The size of the side unrolled of the Extrude & Bevel at `index` of the effects of `n` (on the
/// object itself with `item` `None`, else on its fill or stroke `item`), that a new graphic on it
/// fits: on the side of its solid with the longest outline, as wide as the part about x = 0 that
/// does not reach the side's cut, and as tall as the length across its bevels and walls. `None` when that effect is not a visible Extrude & Bevel with a
/// depth, or its art can't be built.
pub fn graphic_side_size(doc: Option<&Document>, n: &Node, item: Option<usize>, index: usize) -> Option<(f64, f64)> {
    let (fx, shapes) = frame_shapes(doc, n, item, &|fx: &[Effect]| fx.get(index).filter(|e| e.visible && e.id == EXTRUDE).map(|e| (index, e)))?;
    side_size(&crate::merged_params(&fx.id, &fx.params), &shapes)
}

/// The 3D effect `pick` finds in the effects of `n` or its `item`, and the shapes it builds from.
fn frame_shapes(doc: Option<&Document>, n: &Node, item: Option<usize>, pick: &Pick<'_>) -> Option<(Effect, Vec<Profile>)> {
    let n = &*resolve(doc, n, "").ok()?;
    let (fx, shapes) = picked(n, item, pick)?;
    Some((fx.clone(), shapes))
}

/// [`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<usize>, pick: &Pick<'_>) -> Option<graphics::GraphicFrame> {
    let (fx, shapes) = frame_shapes(doc, n, item, pick)?;
    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 (parts, bounds) = solid_parts(&shapes, b);
    let options = extrude_options(&p);
    let map = |face| vectorcraft_three_d::extrude_face_map(bounds, options, view, face);
    let frame = graphics::GraphicFrame::new(bounds, map(PlanarFace::Front), map(PlanarFace::Back));
    // With graphics on the side, the part of it the viewer sees places their handles.
    let side = side_carrier(&fx.id, &p, &parts, bounds)
        .and_then(|k| parts.get(k))
        .and_then(|(_, _, area, rule, _, _)| side_facets(area, *rule, bounds, &p).ok())
        .map(|facets| graphics::SideFrame::of(&facets));
    Some(match side {
        Some(side) => frame.with_side(side),
        None => frame,
    })
}

/// One numbered surface of a 3D object that takes Map Art: what it is, its size laid out flat in
/// points, whether the viewer sees any of it, and the edges of its outline on the page.
#[derive(Clone, Debug, PartialEq)]
pub struct MapSurface {
    pub kind: SurfaceKind,
    pub width: f64,
    pub height: f64,
    pub visible: bool,
    pub outline: Vec<[Point; 2]>,
}

/// The numbered surfaces of the 3D effect at `index` of the effects of `n` (on the object itself
/// with `item` `None`, else on its fill or stroke `item`), which must be an Extrude & Bevel
/// (Classic) or Revolve (Classic), shown or hidden, in the order Map Art numbers them from 1.
/// `None` for any other effect, and when the object's art can't be built.
pub fn map_surfaces_at(doc: Option<&Document>, n: &Node, item: Option<usize>, index: usize) -> Option<Vec<MapSurface>> {
    let n = &*resolve(doc, n, "").ok()?;
    let (fx, shapes) = picked(n, item, &|fx: &[Effect]| fx.get(index).filter(|e| takes_map_art(&e.id)).map(|e| (index, e)))?;
    let p = crate::merged_params(&fx.id, &fx.params);
    let b = union_bounds(&shapes)?;
    // The edges of `facets` on each local surface of `surfaces`, in one pass over the facets: every
    // edge of an end, and the edges of the cells that lie along the sides of the flat surface.
    let seen = |surfaces: &[vectorcraft_three_d::SolidSurface], facets: &[Facet]| -> Vec<Vec<[Point; 2]>> {
        let mut edges: Vec<Vec<[Point; 2]>> = vec![vec![]; surfaces.len()];
        // Each surface laid out flat, and how near a point must be to its side to lie along it.
        let frames: Vec<(Rect, f64)> = surfaces
            .iter()
            .map(|s| {
                let flat = match s.kind {
                    SurfaceKind::Side => Rect::new(-s.width / 2.0, -s.height / 2.0, s.width / 2.0, s.height / 2.0),
                    _ => Rect::new(0.0, 0.0, s.width, s.height),
                };
                (flat, (s.width.max(s.height) * 1e-6).max(1e-9))
            })
            .collect();
        let ends: Vec<(usize, PlanarFace)> = surfaces
            .iter()
            .enumerate()
            .filter_map(|(k, s)| match s.kind {
                SurfaceKind::End(end) => Some((k, end)),
                _ => None,
            })
            .collect();
        for f in facets.iter().filter(|f| !f.away) {
            if let Some(at) = f.end {
                for &(k, end) in &ends {
                    if end == at
                        && let Some(out) = edges.get_mut(k)
                    {
                        for c in &f.contours {
                            out.extend(c.iter().zip(c.iter().cycle().skip(1)).take(c.len()).map(|(a, b)| [*a, *b]));
                        }
                    }
                }
            }
            let Some(cell) = f.cell.as_deref().filter(|c| c.uv.len() == c.page.len()) else { continue };
            let k = cell.surface;
            // A facet of an end adds to an end's surface only its own edges, above.
            if f.end.is_some() && surfaces.get(k).is_some_and(|s| matches!(s.kind, SurfaceKind::End(_))) {
                continue;
            }
            let (Some(&(flat, near)), Some(out)) = (frames.get(k), edges.get_mut(k)) else { continue };
            let count = cell.uv.len();
            for i in 0..count {
                let j = (i + 1) % count;
                let (Some(a), Some(c)) = (cell.uv.get(i), cell.uv.get(j)) else { continue };
                let along = |at: f64, of: fn(&Point) -> f64| (of(a) - at).abs() <= near && (of(c) - at).abs() <= near;
                let on_side = along(flat.x0, |p| p.x) || along(flat.x1, |p| p.x) || along(flat.y0, |p| p.y) || along(flat.y1, |p| p.y);
                if let (true, Some(from), Some(to)) = (on_side, cell.page.get(i), cell.page.get(j)) {
                    out.push([*from, *to]);
                }
            }
        }
        edges
    };
    let listed = |surfaces: &[vectorcraft_three_d::SolidSurface], facets: &[Facet], out: &mut Vec<MapSurface>| {
        for (s, outline) in surfaces.iter().zip(seen(surfaces, facets)) {
            out.push(MapSurface { kind: s.kind, width: s.width, height: s.height, visible: !outline.is_empty(), outline });
        }
    };
    let mut out = vec![];
    if fx.id == crate::CLASSIC_REVOLVE {
        // Revolve (Classic) has one surface: its side, in a group that of the member with the
        // longest profile. A group's members share one sampling of their curves, and a group past
        // those shared limits has no surface.
        let mut options = vectorcraft_three_d::Revolve { map_surface: true, ..crate::revolve::options_of(&fx.id, &p) };
        if is_container(n) {
            options = crate::revolve::shared_options(&shapes, options).ok()?;
        }
        let shape = shapes.get(crate::revolve::graphics_member(&shapes, b, options)?)?;
        let (width, height) = vectorcraft_three_d::revolve_surface_size(&shape.path, b, options)?;
        let surfaces = [vectorcraft_three_d::SolidSurface { kind: SurfaceKind::Side, width, height, center: None }];
        let facets = vectorcraft_three_d::revolve_facets(&shape.path, b, options).unwrap_or_default();
        listed(&surfaces, &facets, &mut out);
        return Some(out);
    }
    let (parts, bounds) = solid_parts(&shapes, b);
    let options = vectorcraft_three_d::Extrude { map_surfaces: true, ..classic_extrude_options(&p) };
    let view = view_options(&p);
    // The faces of the solids count together against the limit the art draws within.
    let mut kept = 0usize;
    for (_, _, area, rule, _, _) in &parts {
        let surfaces = vectorcraft_three_d::extrude_surfaces(area, *rule, bounds, options).unwrap_or_default();
        let facets = vectorcraft_three_d::extrude(area, *rule, bounds, options, view).unwrap_or_default();
        kept = kept.saturating_add(facets.len());
        if kept > MAX_OBJECT_FACES {
            return None;
        }
        listed(&surfaces, &facets, &mut out);
    }
    Some(out)
}

/// [`map_surfaces_at`] for `n` as it is with 3D effect `id` and parameters `p` among the effects of
/// the object itself (`item` `None`) or of its fill or stroke `item`: in place of the effect at
/// `index` when that is an effect `id`, else of the last effect `id` there, or after those effects
/// when there is none. A dialog lists the surfaces of the effect it edits with this, whether or not
/// its preview has changed the object.
pub fn map_surfaces_with(
    doc: Option<&Document>,
    n: &Node,
    (item, index): (Option<usize>, Option<usize>),
    id: &str,
    p: &Value,
) -> Option<Vec<MapSurface>> {
    let mut n = n.clone();
    let effects = n.appearance.effects_mut(item)?;
    let at = index.filter(|&k| effects.get(k).is_some_and(|e| e.id == id)).or_else(|| effects.iter().rposition(|e| e.id == id));
    let index = match at {
        Some(index) => {
            effects.get_mut(index)?.params = p.clone();
            index
        }
        None => {
            effects.push(crate::new_effect(id, p)?);
            effects.len() - 1
        }
    };
    map_surfaces_at(doc, &n, item, index)
}

/// The 3D effect `pick` finds in the effects of `n` (resolved) or of its `item`, with the shapes
/// it builds from: the members of a group or layer, or the object's own profile after the geometry
/// effects before the 3D effect.
fn picked<'n>(n: &'n Node, item: Option<usize>, pick: &Pick<'_>) -> Option<(&'n Effect, Vec<Profile>)> {
    Some(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![] }])
            }
        }
    })
}

/// 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<Rect> {
    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<Effect> {
    let (before, after) = effects.split_at(index.min(effects.len()));
    let after = after.get(1..).unwrap_or_default();
    let kept: Vec<Effect> = 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 graphics mapped onto the mesh when it is the part of a solid's planar face that carries
    /// some ([`split_graphics`]); `None` otherwise.
    pub graphics: Option<MeshGraphics>,
}

impl SolidMesh {
    /// A mesh painted `color`, with no graphics.
    pub fn plain(mesh: Mesh, color: [f32; 4]) -> Self {
        Self { mesh, color, graphics: None }
    }
}

/// The parts of `mesh`, a solid that 3D effect `id` with parameters `p` built about `bounds`, painted
/// `color` from a fill or stroke at `opacity`: for each planar face that carries graphics (Extrude &
/// Bevel's caps, the plane), the triangles on it as a mesh of their own with the art point of each
/// corner ([`MeshGraphics`]), then the rest. Revolve's meshes are split by their side instead
/// (`revolve::surface_meshes`), so a Revolve's mesh stays plain here.
fn split_graphics(id: &str, p: &Value, bounds: Rect, mesh: Mesh, (color, opacity): ([f32; 4], f32)) -> Vec<SolidMesh> {
    let list = graphics::mapped_graphics(p);
    if list.is_empty() || !takes_graphics(id) || id == crate::REVOLVE {
        return vec![SolidMesh::plain(mesh, color)];
    }
    let view = view_options(p);
    let mut rest = mesh;
    let mut out = vec![];
    for face in PlanarFace::ALL {
        if !list.iter().any(|g| g.face == face) {
            continue;
        }
        let on_mesh = if id == ROTATE {
            vectorcraft_three_d::plane_mesh_face(bounds, view)
        } else {
            vectorcraft_three_d::extrude_mesh_face(bounds, extrude_options(p), view, face)
        };
        let Some(on_mesh) = on_mesh else { continue };
        let (mut taken, mut left, mut art) = (Mesh::default(), Mesh::default(), vec![]);
        for t in &rest.triangles {
            let corner = |i: u32| rest.positions.get(i as usize).copied().zip(rest.normals.get(i as usize).copied());
            let Some(corners) = t.iter().map(|&i| corner(i)).collect::<Option<Vec<_>>>() else { continue };
            let points: Option<Vec<Point>> = corners.iter().map(|(m, n)| on_mesh.art_point(*m, *n)).collect();
            let into = match points {
                Some(points) => {
                    art.extend(points);
                    &mut taken
                }
                None => &mut left,
            };
            let base = into.positions.len() as u32;
            for (m, n) in corners {
                into.positions.push(m);
                into.normals.push(n);
            }
            into.triangles.push([base, base + 1, base + 2]);
        }
        rest = left;
        if !taken.is_empty() {
            let graphics = list.iter().filter(|g| g.face == face).cloned().collect();
            let graphics = MeshGraphics { face, graphics, center: bounds.center(), art, opacity, object: 1.0 };
            out.push(SolidMesh { mesh: taken, color, graphics: Some(graphics) });
        }
    }
    if !rest.is_empty() {
        out.insert(0, SolidMesh::plain(rest, color));
    }
    out
}

/// 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<SolidMesh>, 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<Vec<SolidMesh>, 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![];
    // A solid's parts with and without graphics count together against the limit.
    let mut keep = |out: &mut Vec<SolidMesh>, mesh: Mesh, (paint, opacity): (&Paint, f32), bounds: Rect| {
        split_graphics(&fx.id, &p, bounds, mesh, (mesh_color(paint, opacity), opacity))
            .into_iter()
            .try_for_each(|part| keep_mesh(out, total, part, 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)?, (&paint, opacity), b)?;
            }
        }
        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, (&paint, opacity), bounds)?;
            }
            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<Vec<SolidMesh>, 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<Vec<SolidMesh>, 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<Item = &'a Node>) -> Result<Vec<SolidMesh>, 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<Item = &'a Node>) -> Result<Vec<SolidMesh>, 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<Item = &'a Node>, limit: usize) -> Result<Vec<SolidMesh>, 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<Vec<SolidMesh>, 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<SolidMesh> = meshes
        .into_iter()
        .filter(|m| !m.mesh.is_empty())
        .map(|mut m| {
            m.color[3] *= n.opacity.clamp(0.0, 1.0);
            if let Some(g) = &mut m.graphics {
                g.object *= 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;