Files
vectorcraft/crates/effects/src/solids/tests_shadow.rs
T
dotCooCoo 90bcbd7129 3D: a wireframe effect's check casts no shadow
In wireframe mode the effect draws no shadow, so the command check
builds no shadow from its solids either: with Shadows on, Rotate builds
no plane for it, and Extrude & Bevel and Inflate build each solid once.
2026-11-15 01:52:32 -08:00

377 lines
18 KiB
Rust

use serde_json::json;
use vectorcraft_doc::color::Color;
use vectorcraft_doc::{Document, NodeId, StrokeLayer};
use vectorcraft_geom::{Affine, BezPath};
use super::*;
const RED: Color = Color::Rgb { r: 0.8, g: 0.2, b: 0.1 };
/// The 3D and Materials effects that cast shadows.
const CASTING: [&str; 4] = [EXTRUDE, INFLATE, ROTATE, crate::REVOLVE];
fn square_node(id: u64, dx: f64) -> Node {
let mut b = BezPath::new();
b.move_to((100.0 + dx, 100.0));
b.line_to((200.0 + dx, 100.0));
b.line_to((200.0 + dx, 200.0));
b.line_to((100.0 + dx, 200.0));
b.close_path();
Node::path(NodeId(id), PathData::from_bezpath(&b), Appearance::basic(Paint::solid(RED), Paint::None, 0.0))
}
fn art(n: &Node, id: &str) -> Option<Node> {
if id == crate::REVOLVE { crate::revolve_art(n) } else { solid_art(n) }
}
/// The opacity of shadow `n`: a path filled black and nothing else; `None` for any other node.
fn shadow_opacity(n: &Node) -> Option<f32> {
let [AppearanceItem::Fill(fill)] = n.appearance.items.as_slice() else { return None };
(matches!(n.kind, NodeKind::Path { .. }) && fill.paint.color() == Some(Color::BLACK)).then_some(fill.opacity)
}
/// Whether `n` is the shadow of opaque art: a path filled black at 50 %, nothing else.
fn is_shadow(n: &Node) -> bool {
shadow_opacity(n) == Some(0.5)
}
fn shadows(n: &Node) -> usize {
let mut count = 0;
n.walk(&mut |c| count += usize::from(is_shadow(c)));
count
}
#[test]
fn each_3d_effect_draws_its_shadow_behind_its_solid_when_shadows_are_on() {
for id in CASTING {
let mut n = square_node(1, 0.0);
n.appearance.effects.push(crate::new_effect(id, &json!({})).unwrap());
let plain = art(&n, id).unwrap_or_else(|| panic!("{id}"));
assert_eq!(shadows(&plain), 0, "{id}: off by default");
n.appearance.effects[0].params = json!({"shadow": true, "shadowDistance": 50});
let lit = art(&n, id).unwrap_or_else(|| panic!("{id}"));
let children = lit.children().unwrap();
assert!(is_shadow(&children[0]), "{id}: the shadow is drawn first");
assert_eq!(shadows(&lit), 1, "{id}");
// The default light is up and to the left: the shadow on a plane away from the object
// reaches past the solid down and right.
let shadow = children[0].visual_bounds().unwrap();
let solid = children[1..].iter().filter_map(|c| c.visual_bounds()).reduce(|a, b| a.union(b)).unwrap();
assert!(shadow.x1 > solid.x1 && shadow.y1 > solid.y1, "{id}: {shadow:?} {solid:?}");
// The art's bounds take the shadow in.
assert!(lit.visual_bounds().unwrap().contains_rect(shadow), "{id}");
}
}
#[test]
fn the_shadow_moves_with_its_settings() {
for id in CASTING {
let bounds = |params: Value| {
let mut n = square_node(1, 0.0);
n.appearance.effects.push(crate::new_effect(id, &params).unwrap());
let lit = art(&n, id).unwrap();
let shadow = &lit.children().unwrap()[0];
assert!(is_shadow(shadow), "{id} {params}");
shadow.visual_bounds().unwrap()
};
let near = bounds(json!({"shadow": true}));
let far = bounds(json!({"shadow": true, "shadowDistance": 100}));
assert!(far.x1 > near.x1 + 1.0, "{id}: {near:?} {far:?}");
// With the light straight in front, the outline falls about the plane's center; at 10 %
// the plane cuts it to a square 0.4 times the object's size across.
let tight = bounds(json!({"shadow": true, "shadowBounds": 10, "lightHeight": 90}));
let wide = bounds(json!({"shadow": true, "shadowBounds": 400, "lightHeight": 90}));
assert!(wide.width() > tight.width() * 2.0, "{id}: {tight:?} {wide:?}");
let below = bounds(json!({"shadow": true, "shadowPosition": "below", "rotationX": -30}));
assert_ne!(below, near, "{id}");
}
}
#[test]
fn shadow_settings_out_of_range_or_of_the_wrong_kind_are_refused() {
for id in CASTING {
for (params, error) in [
(json!({"shadow": "yes"}), "shadow must be true or false"),
(json!({"shadowPosition": "under"}), "shadowPosition must be behind or below"),
(json!({"shadowPosition": 1}), "shadowPosition must be behind or below"),
(json!({"shadowDistance": 101}), "shadowDistance must be a number from 0 to 100"),
(json!({"shadowDistance": -1}), "shadowDistance must be a number from 0 to 100"),
(json!({"shadowBounds": 5}), "shadowBounds must be a number from 10 to 400"),
(json!({"shadowBounds": "wide"}), "shadowBounds must be a number from 10 to 400"),
] {
let err = validate_three_d_params(id, &params).unwrap_err();
assert!(err.contains(error), "{id} {params}: {err}");
}
let ok = json!({"shadow": true, "shadowPosition": "below", "shadowDistance": 100, "shadowBounds": 10});
assert!(validate_three_d_params(id, &ok).is_ok(), "{id}");
}
}
#[test]
fn a_group_casts_one_shadow_for_all_its_members() {
for id in CASTING {
let mut g = Node::group(NodeId(9), vec![Arc::new(square_node(1, 0.0)), Arc::new(square_node(2, 200.0))]);
g.appearance.effects.push(crate::new_effect(id, &json!({"shadow": true, "lightHeight": 90})).unwrap());
let lit = art(&g, id).unwrap_or_else(|| panic!("{id}"));
assert_eq!(shadows(&lit), 1, "{id}");
let shadow = lit.children().unwrap()[0].clone();
assert!(is_shadow(&shadow), "{id}");
// With the light straight in front, the shadow behind spans both members.
let b = shadow.visual_bounds().unwrap();
assert!(b.x0 < 200.0 && b.x1 > 300.0, "{id}: {b:?}");
}
}
/// A member's opacity mask applies to the part of the shadow it casts, as to its solid: that part
/// is drawn in the mask, the other member's outside it, both on one plane.
#[test]
fn a_masked_member_casts_its_part_of_the_shadow_in_its_mask() {
for id in CASTING {
let mut masked = square_node(2, 200.0);
let mut cover = square_node(3, 200.0);
cover.appearance.items = Appearance::basic(Paint::solid(Color::WHITE), Paint::None, 0.0).items;
masked.extras_mut().mask = Some(Box::new(vectorcraft_doc::OpacityMask::new(cover, true)));
let mut g = Node::group(NodeId(9), vec![Arc::new(square_node(1, 0.0)), Arc::new(masked)]);
g.appearance.effects.push(crate::new_effect(id, &json!({"shadow": true})).unwrap());
let lit = art(&g, id).unwrap_or_else(|| panic!("{id}"));
assert_eq!(shadows(&lit), 2, "{id}: one piece for each member");
let mut in_mask = 0;
lit.walk(&mut |c| {
if c.extras().mask.is_some() {
c.walk(&mut |s| in_mask += usize::from(is_shadow(s)));
}
});
assert_eq!(in_mask, 1, "{id}");
}
}
#[test]
fn transparent_art_and_a_light_that_lights_nothing_cast_no_shadow() {
for id in CASTING {
let mut n = square_node(1, 0.0);
n.appearance.effects.push(crate::new_effect(id, &json!({"shadow": true, "shade": false})).unwrap());
assert_eq!(shadows(&art(&n, id).unwrap()), 0, "{id}: Shading off");
n.appearance.effects[0].params = json!({"shadow": true, "lightIntensity": 0});
assert_eq!(shadows(&art(&n, id).unwrap()), 0, "{id}: no intensity");
// A member at 0 % opacity casts nothing; the other member still casts its shadow.
let mut clear = square_node(2, 200.0);
clear.opacity = 0.0;
let mut g = Node::group(NodeId(9), vec![Arc::new(square_node(1, 0.0)), Arc::new(clear)]);
g.appearance.effects.push(crate::new_effect(id, &json!({"shadow": true, "lightHeight": 90})).unwrap());
let lit = art(&g, id).unwrap_or_else(|| panic!("{id}"));
let shadow = lit.children().unwrap()[0].clone();
assert!(is_shadow(&shadow), "{id}");
let b = shadow.visual_bounds().unwrap();
assert!(b.x1 < 300.0, "{id}: only the visible member casts: {b:?}");
// Art at 50 % casts a shadow half as dark.
let mut half = square_node(1, 0.0);
for item in &mut half.appearance.items {
if let AppearanceItem::Fill(fill) = item {
fill.opacity = 0.5;
}
}
half.appearance.effects.push(crate::new_effect(id, &json!({"shadow": true})).unwrap());
let lit = art(&half, id).unwrap();
assert_eq!(shadow_opacity(&lit.children().unwrap()[0]), Some(0.25), "{id}");
// Art in a blending mode casts its shadow in that mode.
for item in &mut half.appearance.items {
if let AppearanceItem::Fill(fill) = item {
fill.blend = BlendMode::Screen;
}
}
let lit = art(&half, id).unwrap();
let AppearanceItem::Fill(fill) = &lit.children().unwrap()[0].appearance.items[0] else { panic!("{id}: a fill") };
assert_eq!(fill.blend, BlendMode::Screen, "{id}");
}
}
/// With a 3D effect on each of two fills, both fills' shadows are drawn behind both fills' solids.
#[test]
fn the_shadows_of_every_fill_go_behind_every_fill_s_solid() {
for id in CASTING {
let mut n = square_node(1, 0.0);
let fill = n.appearance.items.iter().find(|i| matches!(i, AppearanceItem::Fill(_))).unwrap().clone();
n.appearance.items = vec![fill.clone(), fill];
for item in &mut n.appearance.items {
item.effects_mut().push(crate::new_effect(id, &json!({"shadow": true})).unwrap());
}
let lit = art(&n, id).unwrap_or_else(|| panic!("{id}"));
let children = lit.children().unwrap();
assert!(children.len() >= 4, "{id}");
assert!(is_shadow(&children[0]) && is_shadow(&children[1]), "{id}: both shadows first");
assert!(children[2..].iter().all(|c| !is_shadow(c)), "{id}");
}
}
#[test]
fn expand_appearance_keeps_the_shadow_as_a_path() {
for id in CASTING {
let mut d = Document::new(400.0, 400.0);
let mut n = square_node(1, 0.0);
n.id = d.alloc_id();
n.appearance.effects.push(crate::new_effect(id, &json!({"shadow": true})).unwrap());
let mut stroke = |_: &mut Document, _: &PathData, _: FillRule, _: &StrokeLayer| None;
let expanded = crate::expand_leaf(&mut d, &n, &mut stroke).unwrap_or_else(|| panic!("{id}"));
assert_eq!(shadows(&expanded), 1, "{id}");
let mut effects = 0;
expanded.walk(&mut |c| effects += c.appearance.effects.len());
assert_eq!(effects, 0, "{id}");
// It moves with the object, as the solid does.
let before = art(&n, id).unwrap().children().unwrap()[0].visual_bounds().unwrap();
n.transform(Affine::translate((40.0, 0.0)), false);
let after = art(&n, id).unwrap().children().unwrap()[0].visual_bounds().unwrap();
assert!((after.x0 - before.x0 - 40.0).abs() < 1e-6, "{id}: {before:?} {after:?}");
}
}
/// A square filled red and stroked blue, its stroke as opaque as `stroke`.
fn stroked_square(id: u64, dx: f64, stroke: f32) -> Node {
let mut n = square_node(id, dx);
n.appearance = Appearance::basic(Paint::solid(RED), Paint::solid(Color::rgb(0.1, 0.2, 0.9)), 6.0).into();
for item in &mut n.appearance.items {
if let AppearanceItem::Stroke(s) = item {
s.opacity = stroke;
}
}
n
}
/// Objects with 3D effect `id` and its shadow on (`params`): a filled and stroked square, one whose
/// stroke is half transparent, one whose stroke is fully transparent, and a group of two members,
/// one of them at half opacity.
fn shadowed(id: &str, params: &Value) -> Vec<Node> {
let with = |mut n: Node| {
n.appearance.effects.push(crate::new_effect(id, params).unwrap());
n
};
let mut half = stroked_square(2, 200.0, 1.0);
half.opacity = 0.5;
let group = Node::group(NodeId(9), vec![Arc::new(stroked_square(1, 0.0, 1.0)), Arc::new(half)]);
vec![with(stroked_square(1, 0.0, 1.0)), with(stroked_square(1, 0.0, 0.5)), with(stroked_square(1, 0.0, 0.0)), with(group)]
}
/// The settings the shadows of effect `id` are compared with: the defaults, turned with
/// perspective, and under a colored light, below the object for Extrude & Bevel, Inflate and
/// Rotate and behind it for Revolve.
fn shadow_settings(id: &str) -> [Value; 3] {
let position = if id == crate::REVOLVE { "behind" } else { "below" };
[
json!({"shadow": true}),
json!({"shadow": true, "rotationX": -25, "rotationY": 35, "perspective": 50, "shadowDistance": 40}),
json!({"shadow": true, "shadowPosition": position, "shadowDistance": 30, "lightColor": "#ff8040", "twist": 30}),
]
}
/// How many solids drawing the art of `n` with effect `id` builds.
fn solids_built(n: &Node, id: &str) -> usize {
let start = SOLIDS_BUILT.with(std::cell::Cell::get);
assert!(art(n, id).is_some(), "{id}");
SOLIDS_BUILT.with(std::cell::Cell::get) - start
}
/// Drawing a 3D object with its shadow on builds each of its solids once: the shadow is cast from
/// the faces the solids drawn kept, so it builds no more solids than the art without a shadow.
#[test]
fn a_shadowed_3d_object_builds_each_solid_once() {
for id in CASTING {
for params in shadow_settings(id) {
for (lit, mut plain) in shadowed(id, &params).into_iter().zip(shadowed(id, &params)) {
plain.appearance.effects.iter_mut().for_each(|e| e.params["shadow"] = json!(false));
let mut cast = 0;
art(&lit, id).unwrap().walk(&mut |c| cast += usize::from(shadow_opacity(c).is_some()));
assert!(cast > 0, "{id} {params}");
let built = solids_built(&plain, id);
assert!(built > 0, "{id}");
assert_eq!(solids_built(&lit, id), built, "{id} {params}: the shadow builds no solid of its own");
}
}
}
}
/// The shadow of the faces Extrude & Bevel, Inflate and Rotate kept when they drew their solids,
/// to the bit: the shadow [`cast_shadow`] casts from solids built for the shadow alone.
#[test]
fn the_shadow_cast_from_the_solids_drawn_is_the_shadow_of_solids_built_for_it() {
for id in [EXTRUDE, INFLATE, ROTATE] {
for params in shadow_settings(id) {
for n in shadowed(id, &params) {
let (_, fx) = solid(&n.appearance.effects).unwrap();
let shapes = if is_container(&n) {
members(&n, "").unwrap()
} else {
let (path, rule) = profile(&n).unwrap();
vec![Profile { path, rule, items: solid_paint_sources(&n).1, opacity: 1.0, scopes: vec![] }]
};
let (drawn, _) = art_for(None, &n, fx, &shapes).unwrap();
let p = crate::merged_params(&fx.id, &fx.params);
let (caster, settings, cast) = cast_shadow(&fx.id, &p, &shapes).unwrap().unwrap();
let alone = shadow::scoped_art(n.id, &caster, settings, cast, has_masks(&shapes));
assert!(!alone.is_empty(), "{id} {params}");
assert_eq!(format!("{drawn:?}"), format!("{alone:?}"), "{id} {params}");
}
}
}
}
/// A stroke's solid left out of the art (past its own limits) keeps no faces, and the shadow cast
/// from the faces the solids kept leaves it out without building it: it casts nothing, as it draws
/// nothing, and the fill's solid still casts.
#[test]
fn a_stroke_left_out_of_the_art_casts_no_shadow() {
for id in [EXTRUDE, INFLATE] {
let n = stroked_square(1, 0.0, 1.0);
let (path, rule) = profile(&n).unwrap();
let shapes = [Profile { path, rule, items: solid_paints(&n), opacity: 1.0, scopes: vec![] }];
let p = crate::merged_params(id, &json!({"shadow": true}));
let (parts, bounds) = solid_parts(&shapes, union_bounds(&shapes).unwrap());
let mut built: Vec<Option<SolidFaces>> =
built_solids_cast(id, &p, &parts, bounds, MAX_OBJECT_FACES, true).map(|r| r.unwrap().and_then(|(_, faces)| faces)).collect();
let stroke = parts.iter().position(|(item, ..)| matches!(item, AppearanceItem::Stroke(_))).unwrap();
assert!(built.len() == 2 && built.iter().all(Option::is_some), "{id}");
let (both, _, cast) = cast_built(id, &p, &shapes, built.clone()).unwrap().unwrap();
assert_eq!(cast.len(), 2, "{id}: the fill and the stroke cast");
built[stroke] = None;
let start = SOLIDS_BUILT.with(std::cell::Cell::get);
let (fill, _, cast) = cast_built(id, &p, &shapes, built).unwrap().unwrap();
assert_eq!(SOLIDS_BUILT.with(std::cell::Cell::get), start, "{id}: no solid is built for the shadow");
assert_eq!(cast.len(), 1, "{id}: the stroke left out casts nothing");
assert!(!fill.is_empty() && fill.len() < both.len(), "{id}: only the fill's faces are cast");
}
}
/// A command accepts each shadowed object that draws with its shadow, and with Rotate builds the
/// plane of each visible fill and stroke once for the shadow: a fully transparent one casts nothing.
#[test]
fn the_check_accepts_the_shadowed_objects_that_draw() {
for id in [EXTRUDE, INFLATE, ROTATE] {
for params in shadow_settings(id) {
for n in shadowed(id, &params) {
let mut drawn = 0;
art(&n, id).unwrap().walk(&mut |c| drawn += usize::from(shadow_opacity(c).is_some()));
assert!(drawn > 0, "{id} {params}");
assert_eq!(validate_solid(&n, id, &params), Ok(()), "{id} {params}");
}
}
}
let shadow = json!({"shadow": true});
for (stroke, planes) in [(1.0, 2), (0.5, 2), (0.0, 1)] {
let n = stroked_square(1, 0.0, stroke);
let start = SOLIDS_BUILT.with(std::cell::Cell::get);
assert_eq!(validate_solid(&n, ROTATE, &shadow), Ok(()), "{stroke}");
assert_eq!(SOLIDS_BUILT.with(std::cell::Cell::get) - start, planes, "Rotate, a stroke at {stroke}");
}
}
/// In wireframe mode no shadow is drawn, so the check casts none: with Shadows on, Rotate builds no
/// plane for a shadow, and Extrude & Bevel and Inflate build each solid once, as with the shadow off.
#[test]
fn the_check_casts_no_shadow_in_wireframe_mode() {
let n = stroked_square(1, 0.0, 1.0);
let wire = json!({"shadow": true, "render": {"mode": "wireframe"}});
for (id, solids) in [(ROTATE, 0), (EXTRUDE, 2), (INFLATE, 2)] {
let start = SOLIDS_BUILT.with(std::cell::Cell::get);
assert_eq!(validate_solid(&n, id, &wire), Ok(()), "{id}");
assert_eq!(SOLIDS_BUILT.with(std::cell::Cell::get) - start, solids, "{id}");
}
}