Files
texturecraft/crates/engine/tests/it/instances.rs
chasse20 7bfcf3fc27 Auto: Integrate main and reuse decoded material maps
Preserve main's decoder, atomic-save, material-payload, and USDC limits.
Bound material reads by the remaining payload budget and trim retained
buffers. Replace quadratic image-name searches with map lookups, and
cache validated linked-material maps before synchronization so they
are not decoded twice.

Add import/undo/redo and payload-boundary regressions, extract
ImageIdentity, remove the unchecked scratch example, and complete
scoped cleanup. Correct the integrated style guide's product name.

Validated 546 release tests, Clippy, layering, wasm, formatting, and
focused allocation and lifetime probes.
2026-11-15 04:16:43 +00:00

279 lines
15 KiB
Rust

//! Instance layers across texture sets, mask with height, change-driven invalidation and the
//! frame-budgeted compositor, through engine commands.
use serde_json::{Value, json};
use texturecraft_engine::core::{Channel, Fill, LayerId, LayerKind, Source};
use texturecraft_engine::geom::glam::Vec2;
use texturecraft_engine::geom::primitives;
use texturecraft_engine::{Session, execute};
/// Two texture sets (ball and base) at 256².
fn session() -> Session {
let mut s = Session::new_project("t", primitives::material_ball(), "builtin:material_ball", None, 256).unwrap();
s.viewport = Vec2::new(400.0, 400.0);
s.update();
s
}
fn id(v: Value, key: &str) -> LayerId {
LayerId(v[key].as_u64().unwrap())
}
/// A texel covered by texture set `ts`.
fn covered(s: &Session, ts: usize) -> (u32, u32) {
let g = &s.caches[ts].gbuf;
let i = g.tri.iter().position(|t| *t != texturecraft_engine::geom::NO_TRI).unwrap();
(i as u32 % g.width, i as u32 / g.width)
}
fn rough(s: &mut Session, ts: usize) -> f32 {
s.update();
let (x, y) = covered(s, ts);
s.caches[ts].composite.value(Channel::Roughness, x, y)[0]
}
/// Texels of set `ts` whose base color is red.
fn reds(s: &Session, ts: usize) -> usize {
let c = &s.caches[ts].composite;
(0..256)
.flat_map(|y| (0..256).map(move |x| (x, y)))
.filter(|&(x, y)| s.caches[ts].gbuf.tri[(y * 256 + x) as usize] != u32::MAX)
.filter(|&(x, y)| {
let v = c.value(Channel::BaseColor, x, y);
v[0] > 0.8 && v[1] < 0.2
})
.count()
}
#[test]
fn instances_follow_their_source_across_texture_sets() {
let mut s = session();
let src = id(execute(&mut s, "layer.add.fill", &json!({"roughness": 0.8})).unwrap(), "layer");
let inst = id(execute(&mut s, "layer.instance", &json!({"layer": src.0, "ts": 1})).unwrap(), "layer");
assert!(matches!(s.doc.project.layer(inst).unwrap().kind, LayerKind::Instance { source } if source == src));
assert_eq!(s.doc.project.locate(inst).map(|l| l.0), Some(1));
assert!((rough(&mut s, 1) - 0.8).abs() < 1e-3);
// Editing the source (directly or through the instance) updates the instance's set.
execute(&mut s, "layer.fill.set", &json!({"layer": src.0, "channel": "roughness", "value": 0.3})).unwrap();
assert!(!s.caches[1].dirty.is_empty(), "the instance's set is invalidated");
assert!((rough(&mut s, 1) - 0.3).abs() < 1e-3);
execute(&mut s, "layer.fill.set", &json!({"layer": inst.0, "channel": "roughness", "value": 0.6})).unwrap();
assert!((rough(&mut s, 0) - 0.6).abs() < 1e-3 && (rough(&mut s, 1) - 0.6).abs() < 1e-3);
execute(&mut s, "layer.blend", &json!({"layer": inst.0, "channel": "roughness", "opacity": 0.5})).unwrap();
assert_eq!(s.doc.project.layer(src).unwrap().blend(Channel::Roughness).unwrap().opacity, 0.5, "blending is linked");
// Inspect shows the link; an instance of an instance links to the source.
let stack = execute(&mut s, "layer.list", &json!({"ts": 1})).unwrap();
assert_eq!(stack[0]["instanceOf"]["layer"], src.0, "{stack}");
let again = id(execute(&mut s, "layer.instance", &json!({"layer": inst.0, "ts": 1})).unwrap(), "layer");
assert_eq!(s.doc.project.layer(again).unwrap().instance_source(), Some(src));
// Save/load keeps instances; undo removes them.
let back = Session::from_project_bytes(&s.to_project_bytes().unwrap()).unwrap();
assert_eq!(back.doc.project, s.doc.project);
execute(&mut s, "edit.undo", &Value::Null).unwrap();
assert!(s.doc.project.layer(again).is_err());
}
#[test]
fn painting_a_source_paints_its_instances() {
let mut s = session();
let paint = s.selected_layer().unwrap();
execute(&mut s, "layer.instance", &json!({"layer": paint.0, "ts": 1})).unwrap();
execute(&mut s, "textureSet.select", &json!({"ts": 0})).unwrap();
execute(&mut s, "layer.select", &json!({"layer": paint.0})).unwrap();
execute(&mut s, "tool.material", &json!({"channel": "baseColor", "color": [1.0, 0.0, 0.0]})).unwrap();
execute(&mut s, "tool.brush", &json!({"size": 30, "hardness": 90})).unwrap();
assert_eq!(reds(&s, 1), 0);
// The live stroke shows in the instance before it is committed.
s.begin_stroke(Vec2::new(200.0, 170.0), s.viewport, 1.0).unwrap();
s.continue_stroke(Vec2::new(230.0, 170.0), 1.0);
s.update();
let live = reds(&s, 1);
assert!(live > 0, "the instance shows the live stroke");
s.end_stroke().unwrap();
s.update();
assert!(reds(&s, 1) >= live);
// Painting through the instance paints the source.
let inst = s.doc.project.texture_sets[1].stack.last().copied().unwrap();
execute(&mut s, "layer.select", &json!({"layer": inst.0})).unwrap();
let before = s.doc.pixels.layer(paint, Channel::BaseColor).map(|i| i.allocated_count()).unwrap_or(0);
execute(&mut s, "tool.stroke", &json!({"points": [[150, 330], [250, 330]]})).unwrap();
assert!(s.doc.pixels.layer(paint, Channel::BaseColor).unwrap().allocated_count() >= before);
assert!(s.doc.pixels.layers.keys().all(|(l, _)| *l != inst), "instances hold no pixels");
}
#[test]
fn cycles_are_refused_and_removed_sources_detach() {
let mut s = session();
let g = id(execute(&mut s, "layer.add.group", &Value::Null).unwrap(), "layer");
let fill = id(execute(&mut s, "layer.add.fill", &json!({"roughness": 0.9})).unwrap(), "layer");
assert_eq!(s.doc.project.locate(fill).unwrap().1, Some(g));
// The folder selected: the instance would land inside it and draw itself.
execute(&mut s, "layer.select", &json!({"layer": g.0})).unwrap();
let doc = s.doc.project.clone();
assert!(execute(&mut s, "layer.instance", &json!({"layer": g.0})).is_err());
assert_eq!(s.doc.project, doc, "a refused edit leaves the document as it was");
// Moving an instance of the folder into it is refused too.
execute(&mut s, "layer.select", &json!({"layer": fill.0})).unwrap();
execute(&mut s, "layer.move", &json!({"layer": fill.0, "above": Value::Null})).unwrap();
execute(&mut s, "layer.select", &json!({"layer": fill.0})).unwrap();
let inst = id(execute(&mut s, "layer.instance", &json!({"layer": g.0})).unwrap(), "layer");
assert!(execute(&mut s, "layer.move", &json!({"layer": inst.0, "above": Value::Null, "inside": false})).is_ok());
assert!(execute(&mut s, "layer.move", &json!({"layer": inst.0, "above": g.0, "inside": true})).is_err());
// Removing a source turns its instances into copies that look the same.
let src = id(execute(&mut s, "layer.add.fill", &json!({"roughness": 0.15})).unwrap(), "layer");
execute(&mut s, "layer.instantiateAll", &json!({"layer": src.0})).unwrap();
let inst = s.doc.project.texture_sets[1].stack.last().copied().unwrap();
assert!(s.doc.project.layer(inst).unwrap().instance_source() == Some(src));
let look = rough(&mut s, 1);
assert!((look - 0.15).abs() < 1e-3);
execute(&mut s, "layer.remove", &json!({"layer": src.0})).unwrap();
assert!(s.doc.project.layer(inst).is_err());
let copy = s.doc.project.texture_sets[1].stack.last().copied().unwrap();
assert!(matches!(s.doc.project.layer(copy).unwrap().kind, LayerKind::Fill(_)));
assert!((rough(&mut s, 1) - look).abs() < 1e-4);
s.doc.project.validate().unwrap();
execute(&mut s, "edit.undo", &Value::Null).unwrap();
assert_eq!(s.doc.project.layer(inst).unwrap().instance_source(), Some(src));
}
#[test]
fn paste_as_instance_and_instantiate_or_copy_across_sets() {
let mut s = session();
let src = id(execute(&mut s, "layer.add.fill", &json!({"roughness": 0.7})).unwrap(), "layer");
assert!(execute(&mut s, "layer.pasteInstance", &Value::Null).is_err(), "empty clipboard");
execute(&mut s, "layer.copy", &json!({"layer": src.0})).unwrap();
execute(&mut s, "textureSet.select", &json!({"ts": 1})).unwrap();
let pasted = id(execute(&mut s, "layer.pasteInstance", &Value::Null).unwrap(), "layer");
assert_eq!(s.doc.project.layer(pasted).unwrap().instance_source(), Some(src));
assert_eq!(s.selected_layer(), Some(pasted));
// A cut layer is gone: paste it, not an instance of it.
execute(&mut s, "layer.cut", &json!({"layer": pasted.0})).unwrap();
assert!(execute(&mut s, "layer.pasteInstance", &Value::Null).is_err());
let made = execute(&mut s, "layer.instantiateAll", &json!({"layer": src.0})).unwrap();
let inst = LayerId(made["layers"][0].as_u64().unwrap());
assert_eq!(s.doc.project.layer(inst).unwrap().instance_source(), Some(src));
let made = execute(&mut s, "layer.instantiateAll", &json!({"layer": src.0, "copy": true})).unwrap();
let copy = LayerId(made["layers"][0].as_u64().unwrap());
assert!(matches!(s.doc.project.layer(copy).unwrap().kind, LayerKind::Fill(_)));
// Flattening an instance makes it an independent paint layer with the same look.
let look = rough(&mut s, 1);
execute(&mut s, "layer.remove", &json!({"layer": copy.0})).unwrap();
execute(&mut s, "layer.flatten", &json!({"layer": inst.0})).unwrap();
let l = s.doc.project.layer(inst).unwrap();
assert!(matches!(l.kind, LayerKind::Paint) && l.blend(Channel::Roughness).is_some());
assert!((rough(&mut s, 1) - look).abs() < 2e-3);
}
#[test]
fn mask_with_height_through_layer_set() {
let mut s = session();
let l = id(execute(&mut s, "layer.add.fill", &json!({"color": [1.0, 1.0, 1.0], "height": 0.5})).unwrap(), "layer");
execute(&mut s, "mask.add.black", &Value::Null).unwrap();
execute(&mut s, "effect.add.fill", &json!({"value": 0.5})).unwrap();
let (x, y) = covered(&s, 0);
s.update();
let plain = s.caches[0].composite.value(Channel::BaseColor, x, y)[0];
let r = execute(&mut s, "layer.set", &json!({"layer": l.0, "heightMask": {"enabled": true, "contrast": 1.0, "offset": 0.0}})).unwrap();
assert_eq!(r["heightMask"]["enabled"], true);
s.update();
let with = s.caches[0].composite.value(Channel::BaseColor, x, y)[0];
assert!((plain - 0.75).abs() < 0.01 && (with - 1.0).abs() < 0.01, "{plain} {with}");
let inspect = execute(&mut s, "layer.list", &Value::Null).unwrap();
assert_eq!(inspect[0]["heightMask"]["contrast"], 1.0);
execute(&mut s, "layer.set", &json!({"layer": l.0, "heightMask": false})).unwrap();
assert!(!s.doc.project.layer(l).unwrap().height_mask.enabled);
assert!(execute(&mut s, "layer.set", &json!({"layer": l.0})).is_err());
assert!(execute(&mut s, "layer.set", &json!({"layer": l.0, "heightMask": 3})).is_err());
let hostile = execute(&mut s, "layer.set", &json!({"layer": l.0, "heightMask": {"contrast": 1e30, "offset": -1e30}})).unwrap();
assert_eq!(hostile["heightMask"]["contrast"], 64.0);
assert_eq!(hostile["heightMask"]["offset"], -1.0);
}
#[test]
fn edits_invalidate_only_the_sets_they_change() {
let mut s = session();
let l = id(execute(&mut s, "layer.add.fill", &json!({"roughness": 0.4})).unwrap(), "layer");
s.update();
execute(&mut s, "layer.rename", &json!({"layer": l.0, "name": "Renamed"})).unwrap();
assert_eq!(s.pending_tiles(), 0, "a rename changes no pixels");
execute(&mut s, "layer.fill.set", &json!({"layer": l.0, "channel": "roughness", "value": 0.2})).unwrap();
assert!(!s.caches[0].dirty.is_empty() && s.caches[1].dirty.is_empty(), "only the edited set");
s.update();
execute(&mut s, "edit.undo", &Value::Null).unwrap();
assert!(!s.caches[0].dirty.is_empty() && s.caches[1].dirty.is_empty());
assert!((rough(&mut s, 0) - 0.4).abs() < 1e-3);
}
#[test]
fn importing_images_invalidates_only_sets_with_newly_resolved_references() {
use std::sync::Arc;
let mut session = session();
let referenced_layer = session.doc.project.texture_sets[1].stack[0];
session
.edit("Reference missing image", |session| {
let mut fill = Fill::default();
fill.sources.insert(Channel::BaseColor, Source::image("later.png"));
session.doc.project.layer_mut(referenced_layer).unwrap().kind = LayerKind::Fill(fill);
Ok(())
})
.unwrap();
session.update();
let mut image_bytes = Vec::new();
let image = image::RgbaImage::from_pixel(1, 1, image::Rgba([255, 0, 0, 255]));
image.write_to(&mut std::io::Cursor::new(&mut image_bytes), image::ImageFormat::Png).unwrap();
session.import_resource_bytes("later.png", image_bytes.clone()).unwrap();
assert!(session.caches[0].dirty.is_empty(), "unrelated set stays clean");
assert!(!session.caches[1].dirty.is_empty(), "newly resolved image invalidates its set");
session.update();
let (x, y) = covered(&session, 1);
assert!(session.caches[1].composite.value(Channel::BaseColor, x, y)[0] > 0.9);
let imported_image = Arc::downgrade(&session.images["later.png"]);
session.undo().unwrap();
assert!(!session.caches[0].dirty.is_empty(), "resource removal retains broad invalidation");
assert!(!session.caches[1].dirty.is_empty());
assert!(imported_image.upgrade().is_none(), "undo releases the decoded image even while encoded bytes remain in history");
session.update();
session.redo().unwrap();
assert!(session.caches[0].dirty.is_empty());
assert!(!session.caches[1].dirty.is_empty());
assert!(!imported_image.ptr_eq(&Arc::downgrade(&session.images["later.png"])), "redo decodes a new image allocation");
session.update();
session.import_resource_bytes("unused.png", image_bytes).unwrap();
assert!(session.caches.iter().all(|cache| cache.dirty.is_empty()), "unused image leaves every set clean");
let resolved_image = Arc::downgrade(&session.images["later.png"]);
session.sync_images();
assert!(resolved_image.ptr_eq(&Arc::downgrade(&session.images["later.png"])), "sync reuses already decoded images");
}
#[test]
fn budgeted_updates_spread_work_and_end_identical() {
let mut s = session();
execute(&mut s, "textureSet.resolution", &json!({"ts": 0, "resolution": 1024})).unwrap();
execute(&mut s, "layer.add.fill", &Value::Null).unwrap();
execute(&mut s, "layer.fill.set", &json!({"channel": "baseColor", "procedural": "grunge"})).unwrap();
execute(&mut s, "mask.add.black", &Value::Null).unwrap();
execute(&mut s, "effect.add.generator", &json!({"generator": "position"})).unwrap();
execute(&mut s, "effect.add.filter", &json!({"filter": "blur", "radius": 30})).unwrap();
s.update();
let full = s.caches[0].composite.clone();
s.caches[0].invalidate_all();
// A clock that is always over budget: one chunk per call.
let mut calls = 0;
while s.pending_tiles() > 0 {
let before = s.pending_tiles();
s.update_for(0.0, || 1.0);
assert!(s.pending_tiles() < before);
calls += 1;
}
assert!(calls > 1, "the work was spread over calls");
assert!(s.caches[0].composite == full, "chunked compositing gives the same pixels");
assert!(s.memory().composites > 0);
}