Files
vectorcraft/crates/effects/src/solids/tests_shadow.rs
T
dotCooCoo 1b268a725e 3D: a render with a shadow builds each solid once
With Shadows on, Extrude & Bevel, Inflate, Rotate and Revolve built
every solid twice: once for the art and again for the shadow. The build
that draws a solid now also keeps the faces its shadow is cast from and
the projection they were built with, and the shadow is cast from them.
The art and the shadow are unchanged.

- three-d: the solid builder can keep the projected facets and the
  view-space faces together (`Keep::Both`); `extrude_shadowed`,
  `plane_shadowed`, `inflate_shadowed` and `revolve_shadowed` return
  both, and `ShadowCaster::add_solid` adds the kept faces. Revolve's
  sweep draws the surface and keeps the shadow's faces in one pass; a
  shadow past its limits still gives the same error while the surface
  draws.
- effects: the solids drawn hand their faces to the shadow. A stroke's
  solid left out of the art is still built for the shadow alone, as
  before.

Tests compare each solid and its shadow with the two built apart, to
the bit, and count the solids built for a shadowed object.
2026-11-13 21:48:53 -08:00

315 lines
15 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}");
}
}
}
}