Files
effectcraft/crates/effects/src/sim3/tests.rs
T

373 lines
14 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
use super::*;
use crate::{EffectEnv, MaskShape, run_fx};
fn run(vals: &[(&str, Value)], t: f64) -> Image {
run_fx("ec.sim.particleplayground", vals, Image::filled(80, 60, [0.2, 0.2, 0.2, 1.0]), t, EffectEnv::default()).img
}
fn cannon(t: f64) -> Image {
run(&[("cannon/cannonPosition", Value::Vec2([40.0, 50.0])), ("cannon/velocity", num(60.0)), ("gravity/gravityForce", num(30.0))], t)
}
#[test]
fn cannon_stream_is_seek_consistent() {
let a = cannon(1.0);
// Particles replace the layer: some coverage, mostly transparent, red.
let cov: f32 = a.data.iter().map(|p| p[3]).sum();
assert!(cov > 5.0, "{cov}");
assert!(a.data.iter().any(|p| p[3] > 0.5 && p[0] > 0.5 && p[1] < 0.1));
// Seek back and forth: the same frame every time.
let _ = cannon(2.0);
let b = cannon(1.0);
assert_eq!(a.data, b.data);
let c = cannon(0.5);
assert_ne!(a.data, c.data);
// Nothing has been fired at time 0.
let z = cannon(0.0);
assert!(z.data.iter().all(|p| p[3] == 0.0));
}
#[test]
fn grid_falls_with_gravity_and_bounces_off_a_wall() {
let grid = |t: f64, env: EffectEnv| {
run_fx(
"ec.sim.particleplayground",
&[
("cannonEnabled", Value::Bool(false)),
("grid/gridPosition", Value::Vec2([40.0, 10.0])),
("grid/gridWidth", num(40.0)),
("grid/gridHeight", num(0.0)),
("grid/particlesAcross", num(5.0)),
("grid/particlesDown", num(1.0)),
("gravity/gravityForce", num(100.0)),
("wall/wallBoundary", num(1.0)),
],
Image::new(80, 60),
t,
env,
)
.img
};
// Alpha-weighted mean height of the particles.
let row_of = |img: &Image| {
let (mut s, mut n) = (0.0f64, 0.0f64);
for y in 0..60 {
for x in 0..80 {
let a = img.get(x, y)[3] as f64;
s += (y as f64 + 0.5) * a;
n += a;
}
}
(s / n.max(1e-9)).round() as i64
};
let t0 = grid(0.0, EffectEnv::default());
let t1 = grid(0.5, EffectEnv::default());
assert_eq!(row_of(&t0), 10);
// ½ g t² = 12.5 px.
assert!((row_of(&t1) - 22).abs() <= 2, "{}", row_of(&t1));
// A wall (mask 1) whose floor is at y = 15 keeps them above it.
let masks = [MaskShape { name: "w".into(), points: vec![[0.0, 0.0], [80.0, 0.0], [80.0, 15.0], [0.0, 15.0]], closed: true, inverted: false }];
let env = EffectEnv { masks: &masks, ..Default::default() };
let w = grid(1.5, env);
assert!(row_of(&w) <= 16, "{}", row_of(&w));
}
#[test]
fn repel_spreads_particles() {
let spread = |force: f64| {
let img = run(
&[
("cannonEnabled", Value::Bool(false)),
("grid/gridPosition", Value::Vec2([40.0, 30.0])),
("grid/gridWidth", num(6.0)),
("grid/gridHeight", num(6.0)),
("grid/particlesAcross", num(3.0)),
("grid/particlesDown", num(3.0)),
("gravity/gravityForce", num(0.0)),
("repel/repelForce", num(force)),
("repel/repelForceRadius", num(20.0)),
],
0.5,
);
let (mut x0, mut x1) = (80, 0);
for y in 0..60 {
for x in 0..80 {
if img.get(x, y)[3] > 0.3 {
x0 = x0.min(x);
x1 = x1.max(x);
}
}
}
x1 - x0
};
assert!(spread(0.2) > spread(0.0) + 4, "{} vs {}", spread(0.2), spread(0.0));
}
#[test]
fn property_mapper_and_layer_map_read_layers() {
// Without a host, the layer-based features are inert (deterministic output).
let a = run(
&[
("persistentPropertyMapper/mapRedTo", Value::Enum(8)),
("persistentPropertyMapper/redMin", num(-50.0)),
("persistentPropertyMapper/redMax", num(50.0)),
],
0.7,
);
let b = run(
&[
("persistentPropertyMapper/mapRedTo", Value::Enum(8)),
("persistentPropertyMapper/redMin", num(-50.0)),
("persistentPropertyMapper/redMax", num(50.0)),
],
0.7,
);
assert_eq!(a.data, b.data);
let st = Pg { persistent: Some(mapper(Image::filled(4, 4, [1.0, 0.0, 0.5, 1.0]), [(15, 0, 0.0, 120.0), (0, 0, 0.0, 1.0), (9, 0, 0.0, 2.0)])), ..bare(1) };
let mut s = PgState::default();
s.parts.push(PgParticle::new([1.0, 1.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID));
st.step(&mut s);
// Red 1 → X speed 120 px/s; blue 0.5 → scale 1.
assert!((s.parts[0].v[0] - 120.0).abs() < 1e-3);
assert!((s.parts[0].scale[0] - 1.0).abs() < 1e-3);
}
/// A Pg with nothing switched on.
fn bare(seed: u32) -> Pg {
Pg {
cannon: false,
pos: [0.0; 2],
barrel_angle: 0.0,
barrel_radius: 0.0,
rate: 0.0,
dir_spread: 0.0,
vel: 0.0,
vel_spread: 0.0,
color: [1.0; 4],
radius: 2.0,
cannon_text: vec![],
pex_radius: 0.0,
pex_dispersion: 0.0,
pex_affects: Affects::default(),
gravity: [0.0; 2],
grav_spread: 0.0,
grav_affects: Affects::default(),
repel: 0.0,
repel_radius: 0.0,
repel_affects: Affects::default(),
wall: None,
wall_affects: Affects::default(),
persistent: None,
ephemeral: None,
seed,
bounds: [-1e6, -1e6, 1e6, 1e6],
}
}
fn mapper(img: Image, chans: [(u32, u32, f32, f32); 3]) -> Mapper {
Mapper { map: MapImg { img, k: [1.0; 2], o: [0.0; 2] }, chans, affects: Affects::default() }
}
#[test]
fn barrel_radius_square_or_disc() {
let pg = |r: f32| Pg { cannon: true, barrel_radius: r, ..bare(3) };
let (sq, disc) = (pg(10.0), pg(-10.0));
let mut corner = false;
for id in 0..400 {
let a = sq.spawn(id).p;
assert!(a[0].abs() <= 10.0 && a[1].abs() <= 10.0);
// A square barrel fills its corners (both offsets in use, not a line).
corner |= a[0].abs() > 7.5 && a[1].abs() > 7.5;
let b = disc.spawn(id).p;
assert!(b[0].hypot(b[1]) <= 10.0 + 1e-4);
}
assert!(corner);
// Radius 0: every particle starts at the cannon position.
assert_eq!(pg(0.0).spawn(5).p, [0.0, 0.0]);
}
#[test]
fn mapper_drives_position_and_opacity_in_ae_order() {
let st = Pg { persistent: Some(mapper(Image::filled(4, 4, [1.0, 0.5, 0.25, 1.0]), [(12, 0, 0.0, 30.0), (20, 0, 0.0, 1.0), (4, 0, 0.0, 1.0)])), ..bare(1) };
assert_eq!(MAP_TARGETS[12], "X");
assert_eq!(MAP_TARGETS[20], "Opacity");
assert_eq!(MAP_TARGETS[26], "Scale Speed");
let mut s = PgState::default();
s.parts.push(PgParticle::new([1.0, 1.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID));
st.step(&mut s);
assert!((s.parts[0].p[0] - 30.0).abs() < 1e-3, "{:?}", s.parts[0].p);
assert!((s.parts[0].c[3] - 0.5).abs() < 1e-3);
assert!((s.parts[0].friction - 0.25).abs() < 1e-3);
}
#[test]
fn ephemeral_mapper_holds_for_one_step_with_operators() {
// Ephemeral X Speed = 60 px/s (Set): the particle moves, but keeps no velocity.
let st = Pg { ephemeral: Some(mapper(Image::filled(4, 4, [1.0, 1.0, 1.0, 1.0]), [(15, 0, 0.0, 60.0), (0, 0, 0.0, 1.0), (0, 0, 0.0, 1.0)])), ..bare(1) };
let mut s = PgState::default();
s.parts.push(PgParticle::new([1.0, 1.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID));
st.step(&mut s);
assert!((s.parts[0].p[0] - 2.0).abs() < 1e-4, "{:?}", s.parts[0].p);
assert!(s.parts[0].v[0].abs() < 1e-4);
// Operators: Add / Multiply / Max on the particle's own value.
let op = |o: u32, cur: f32| {
let m = mapper(Image::filled(4, 4, [1.0, 1.0, 1.0, 1.0]), [(21, o, 0.0, 3.0), (0, 0, 0.0, 1.0), (0, 0, 0.0, 1.0)]);
let mut q = PgParticle::new([1.0, 1.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID);
q.mass = cur;
m.apply(&mut q);
q.mass
};
assert_eq!(MAP_OPERATORS[1], "Add");
assert!((op(1, 2.0) - 5.0).abs() < 1e-5);
assert!((op(4, 2.0) - 6.0).abs() < 1e-5);
assert!((op(6, 5.0) - 5.0).abs() < 1e-5);
assert!((op(2, 5.0) - 2.0).abs() < 1e-5, "Difference");
}
#[test]
fn affects_select_by_source_age_and_characters() {
let mut q = PgParticle::new([0.0; 2], [0.0; 2], [1.0; 4], 2.0, 0, SRC_CANNON);
let a = Affects { from: 2, ..Default::default() };
assert_eq!(a.weight(&q), 0.0, "grid only");
q.src = SRC_GRID;
assert_eq!(a.weight(&q), 1.0);
let older = Affects { age: 1.0, ..Default::default() };
q.age = 0.5;
assert_eq!(older.weight(&q), 0.0);
q.age = 1.5;
assert_eq!(older.weight(&q), 1.0);
let younger = Affects { age: -1.0, feather: 1.0, ..Default::default() };
q.age = 1.0;
assert!((younger.weight(&q) - 0.5).abs() < 1e-5, "feathered");
let chars = Affects { chars: vec!['A', 'B'], ..Default::default() };
q.ch = 'B' as u32;
assert_eq!(chars.weight(&q), 1.0);
q.ch = 'C' as u32;
assert_eq!(chars.weight(&q), 0.0);
// Gravity restricted to the cannon leaves grid particles in place.
let st = Pg { gravity: [0.0, 100.0], grav_affects: Affects { from: 1, ..Default::default() }, ..bare(1) };
let mut s = PgState::default();
s.parts.push(PgParticle::new([5.0, 5.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID));
s.parts.push(PgParticle::new([5.0, 5.0], [0.0; 2], [1.0; 4], 2.0, 1, SRC_CANNON));
for _ in 0..10 {
st.step(&mut s);
}
assert_eq!(s.parts[0].p, [5.0, 5.0]);
assert!(s.parts[1].p[1] > 5.0);
}
#[test]
fn particle_exploder_bursts_big_particles() {
let st = Pg { pex_radius: 2.0, pex_dispersion: 30.0, ..bare(1) };
let mut s = PgState::default();
s.parts.push(PgParticle::new([50.0, 50.0], [0.0; 2], [1.0; 4], 6.0, 0, SRC_GRID));
s.next_id = 1;
st.step(&mut s);
assert_eq!(s.parts.len(), 9, "(6/2)² new particles");
assert!(s.parts.iter().all(|q| q.r == 2.0 && q.src == SRC_PARTICLE_EXPLODER));
st.step(&mut s);
assert_eq!(s.parts.len(), 9, "new particles do not burst again");
// Lifespan from a mapper removes particles once they are older.
let life = Pg { persistent: Some(mapper(Image::filled(4, 4, [1.0; 4]), [(22, 0, 0.0, 0.05), (0, 0, 0.0, 1.0), (0, 0, 0.0, 1.0)])), ..bare(1) };
let mut s = PgState::default();
s.parts.push(PgParticle::new([1.0, 1.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID));
for _ in 0..2 {
life.step(&mut s);
}
assert_eq!(s.parts.len(), 1);
for _ in 0..3 {
life.step(&mut s);
}
assert!(s.parts.is_empty());
}
#[test]
fn text_particles_draw_characters() {
let grid = |text: &str| {
run(
&[
("cannonEnabled", Value::Bool(false)),
("grid/gridPosition", Value::Vec2([40.0, 30.0])),
("grid/gridWidth", num(40.0)),
("grid/gridHeight", num(0.0)),
("grid/particlesAcross", num(3.0)),
("grid/particlesDown", num(1.0)),
("grid/gridParticleRadius", num(16.0)),
("gravity/gravityForce", num(0.0)),
("options/gridText", Value::Str(text.into())),
],
0.1,
)
};
let dots = grid("");
let text = grid("I-O");
assert_ne!(dots.data, text.data);
// "I" is a vertical bar: ink above and below the grid point, not a round dot.
assert!(text.get(20, 26)[3] > 0.3 && text.get(20, 34)[3] > 0.3, "{:?}", text.get(20, 26));
// A space leaves its grid point empty.
let gap = grid("I O");
assert!(gap.get(40, 30)[3] < 0.05);
// Cannon text: particles carry the characters in order.
let pg = Pg { cannon_text: vec!['A', 'B'], ..bare(1) };
assert_eq!(pg.spawn(0).ch, 'A' as u32);
assert_eq!(pg.spawn(3).ch, 'B' as u32);
}
#[test]
fn layer_map_shows_the_map_layer_at_its_time_offset() {
/// A 6×6 map layer whose colour encodes the comp time it was fetched at.
struct Clock;
impl crate::EffectHost for Clock {
fn layer(&self, _: u64, _: bool) -> Option<crate::LayerPixels> {
None
}
fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
None
}
fn layer_at(&self, _: u64, t: f64, _: bool) -> Option<crate::LayerPixels> {
let v = (t as f32 / 4.0).clamp(0.0, 1.0);
Some(crate::LayerPixels { buf: Buf { img: Image::filled(6, 6, [v, 0.0, 1.0 - v, 1.0]), offset: [0.0; 2], scale: 1.0 }, size: [6.0, 6.0] })
}
}
let render = |kind: u32, offset: f64| {
let vals = [
("cannonEnabled", Value::Bool(false)),
("grid/gridPosition", Value::Vec2([40.0, 30.0])),
("grid/particlesAcross", num(1.0)),
("grid/particlesDown", num(1.0)),
("gravity/gravityForce", num(0.0)),
("layerMap/layerMapLayer", Value::Layer(Some(9))),
("layerMap/timeOffsetType", Value::Enum(kind)),
("layerMap/timeOffset", num(offset)),
];
let env = EffectEnv { host: Some(&Clock), comp_time: 1.0, frame_rate: 10.0, ..Default::default() };
run_fx("ec.sim.particleplayground", &vals, Image::filled(80, 60, [0.2, 0.2, 0.2, 1.0]), 1.0, env).img
};
// The particle is a 6×6 copy of the map layer.
let rel = render(0, 1.0);
assert!(rel.get(40, 30)[3] > 0.99 && rel.get(46, 30)[3] < 0.01);
assert!((rel.get(40, 30)[0] - 0.5).abs() < 1e-3, "relative: now + 1 s = 2 s");
let abs = render(1, 3.0);
assert!((abs.get(40, 30)[0] - 0.75).abs() < 1e-3, "absolute: 3 s");
}
#[test]
fn cc_hair_grows_from_opaque_pixels() {
let mut img = Image::new(60, 60);
for y in 20..40 {
for x in 20..40 {
img.set(x, y, [0.8, 0.6, 0.4, 1.0]);
}
}
let out = run_fx("ec.sim.cchair", &[("length", num(12.0)), ("density", num(300.0))], img.clone(), 0.0, EffectEnv::default());
// Hair reaches beyond the square (above it: hair leans up, then droops).
let outside: f32 = (0..60).flat_map(|x| (0..20).map(move |y| (x, y))).map(|(x, y)| out.img.get(x, y)[3]).sum();
assert!(outside > 1.0, "{outside}");
// Nothing grows from transparent areas far away.
assert_eq!(out.img.get(2, 58)[3], 0.0);
let again = run_fx("ec.sim.cchair", &[("length", num(12.0)), ("density", num(300.0))], img.clone(), 3.0, EffectEnv::default());
assert_eq!(out.img.data, again.img.data);
let none = run_fx("ec.sim.cchair", &[("length", num(0.0))], img.clone(), 0.0, EffectEnv::default());
assert_eq!(none.img.data, img.data);
}