Files

794 lines
40 KiB
Rust

use serde_json::{Value, json};
use texturecraft_engine::core::Channel;
use texturecraft_engine::geom::primitives;
use texturecraft_engine::{Session, command_specs, execute};
fn session() -> Session {
let mut s = Session::new_project("t", primitives::sphere(1.0, 48, 24), "builtin:sphere", None, 256).unwrap();
s.viewport = texturecraft_engine::geom::glam::Vec2::new(400.0, 400.0);
s.camera.yaw = 0.0;
s.camera.pitch = 0.0;
s.update();
s
}
#[test]
fn scripted_stroke_paints_and_undo_restores() {
let mut s = session();
execute(&mut s, "tool.material", &json!({"channel": "baseColor", "color": [1.0, 0.0, 0.0]})).unwrap();
execute(&mut s, "tool.brush", &json!({"size": 20, "hardness": 90})).unwrap();
let r = execute(&mut s, "tool.stroke", &json!({"points": [[180, 200], [220, 200]]})).unwrap();
assert!(r["stamps"].as_u64().unwrap() > 1);
// The texel under the screen center is now red.
let hit = s.pick(texturecraft_engine::geom::glam::Vec2::new(200.0, 200.0), s.viewport).unwrap();
let res = 256.0;
let (x, y) = ((hit.uv.x * res) as u32, (hit.uv.y * res) as u32);
let v = s.caches[0].composite.value(Channel::BaseColor, x, y);
assert!(v[0] > 0.9 && v[1] < 0.1, "{v:?}");
execute(&mut s, "edit.undo", &Value::Null).unwrap();
s.update();
let v = s.caches[0].composite.value(Channel::BaseColor, x, y);
assert!((v[0] - 0.5).abs() < 0.01, "{v:?}");
execute(&mut s, "edit.redo", &Value::Null).unwrap();
s.update();
assert!(s.caches[0].composite.value(Channel::BaseColor, x, y)[0] > 0.9);
}
#[test]
fn layers_masks_materials_and_bake() {
let mut s = session();
execute(&mut s, "layer.add.fill", &json!({"color": "#336699", "roughness": 0.2})).unwrap();
execute(&mut s, "mask.add.black", &Value::Null).unwrap();
execute(&mut s, "effect.add.generator", &json!({"generator": "position", "level": 0.5})).unwrap();
execute(&mut s, "bake.run", &json!({"resolution": 128, "rays": 8})).unwrap();
execute(&mut s, "material.apply", &json!({"material": "steel_painted_worn"})).unwrap();
execute(&mut s, "layer.group", &Value::Null).unwrap();
execute(&mut s, "layer.duplicate", &Value::Null).unwrap();
let inspect = execute(&mut s, "project.inspect", &Value::Null).unwrap();
assert!(inspect["layers"].as_array().unwrap().len() >= 3, "{inspect}");
s.doc.project.validate().unwrap();
s.update();
for _ in 0..7 {
execute(&mut s, "edit.undo", &Value::Null).unwrap();
}
assert_eq!(s.doc.project.walk(0).len(), 1, "back to the initial paint layer");
}
#[test]
fn generator_offset_is_settable_and_clamped() {
let mut s = session();
execute(&mut s, "layer.add.fill", &json!({})).unwrap();
execute(&mut s, "mask.add.black", &Value::Null).unwrap();
let r = execute(&mut s, "effect.add.generator", &json!({"generator": "position", "offset": 0.25})).unwrap();
let eff = r["effect"].as_u64().unwrap();
let offset = |s: &Session| {
let layer = s.doc.project.layers.values().find(|l| l.mask.is_some()).unwrap();
layer
.mask
.as_ref()
.unwrap()
.effects
.iter()
.find_map(|e| match &e.kind {
texturecraft_engine::core::EffectKind::Generator(g) => Some(g.offset),
_ => None,
})
.unwrap()
};
assert_eq!(offset(&s), 0.25);
execute(&mut s, "effect.set", &json!({"effect": eff, "offset": 5.0})).unwrap();
assert_eq!(offset(&s), 1.0, "clamped to 1");
}
fn generator_offset_of(s: &Session) -> f32 {
let layer = s.doc.project.layers.values().find(|l| l.mask.is_some()).unwrap();
layer
.mask
.as_ref()
.unwrap()
.effects
.iter()
.find_map(|e| match &e.kind {
texturecraft_engine::core::EffectKind::Generator(g) => Some(g.offset),
_ => None,
})
.unwrap()
}
#[test]
fn generator_offset_survives_save_and_reopen_and_undo_restores_it() {
let mut s = session();
execute(&mut s, "layer.add.fill", &json!({})).unwrap();
execute(&mut s, "mask.add.black", &Value::Null).unwrap();
let r = execute(&mut s, "effect.add.generator", &json!({"generator": "position", "offset": 0.25})).unwrap();
let eff = r["effect"].as_u64().unwrap();
execute(&mut s, "effect.set", &json!({"effect": eff, "offset": -0.6})).unwrap();
assert_eq!(generator_offset_of(&s), -0.6);
let path = std::env::temp_dir().join(format!("tc-generator-offset-{}.tcraft", std::process::id()));
let path = path.to_str().unwrap();
execute(&mut s, "file.saveCopy", &json!({"path": path})).unwrap();
let reopened = texturecraft_engine::file_cmds::open_path(path);
let _ = std::fs::remove_file(path);
assert_eq!(generator_offset_of(&reopened.unwrap()), -0.6, "the offset is saved and read back");
execute(&mut s, "edit.undo", &Value::Null).unwrap();
assert_eq!(generator_offset_of(&s), 0.25, "undo restores the previous offset");
}
#[test]
fn generator_offset_works_alongside_curvature_mode_and_sizes() {
let mut s = session();
execute(&mut s, "layer.add.fill", &json!({})).unwrap();
execute(&mut s, "mask.add.black", &Value::Null).unwrap();
let r = execute(&mut s, "effect.add.generator", &json!({"generator": "curvature", "mode": "cavities", "offset": 0.5})).unwrap();
let eff = r["effect"].as_u64().unwrap();
assert_eq!(generator_offset_of(&s), 0.5);
execute(&mut s, "effect.set", &json!({"effect": eff, "offset": -0.5, "sizes": [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.5]})).unwrap();
assert_eq!(generator_offset_of(&s), -0.5);
let inspect = execute(&mut s, "project.inspect", &Value::Null).unwrap().to_string();
assert!(inspect.contains(r#""offset":-0.5"#) && inspect.contains(r#""mode":"Cavities""#), "{inspect}");
assert!(inspect.contains(r#""sizes":[0.0,0.0,0.0,1.0,0.0,0.0,0.5]"#), "{inspect}");
}
#[test]
fn layer_rename_and_undo() {
let mut s = session();
let layer_id = s.selected_layer().unwrap();
let orig_name = s.doc.project.layer(layer_id).unwrap().name.clone();
execute(&mut s, "layer.rename", &json!({"name": "Custom Paint"})).unwrap();
assert_eq!(s.doc.project.layer(layer_id).unwrap().name, "Custom Paint");
execute(&mut s, "edit.undo", &Value::Null).unwrap();
assert_eq!(s.doc.project.layer(layer_id).unwrap().name, orig_name);
execute(&mut s, "edit.redo", &Value::Null).unwrap();
assert_eq!(s.doc.project.layer(layer_id).unwrap().name, "Custom Paint");
}
#[test]
fn undo_and_redo_jump_several_steps() {
let mut s = session();
let layer = s.selected_layer().unwrap();
let name = |s: &Session| s.doc.project.layer(layer).unwrap().name.clone();
let first = name(&s);
for n in ["A", "B", "C"] {
execute(&mut s, "layer.rename", &json!({"name": n})).unwrap();
}
let base = s.history_labels().len() - 3;
// Two back to "A": the undone steps wait to be redone, next first.
assert_eq!(execute(&mut s, "edit.undo", &json!({"steps": 2})).unwrap(), json!({"undone": "Rename layer", "steps": 2}));
assert_eq!(name(&s), "A");
assert_eq!(s.redo_labels().len(), 2);
assert_eq!(execute(&mut s, "edit.history", &Value::Null).unwrap()["redo"].as_array().unwrap().len(), 2);
// Forward past the end stops at "C"; back past the start stops at the first state.
assert_eq!(execute(&mut s, "edit.redo", &json!({"steps": 99})).unwrap()["steps"], 2);
assert_eq!(name(&s), "C");
let r = execute(&mut s, "edit.undo", &json!({"steps": 1_000_000})).unwrap();
assert_eq!(r["steps"].as_u64().unwrap() as usize, base + 3);
assert_eq!(name(&s), first);
assert!(execute(&mut s, "edit.undo", &json!({"steps": 2})).is_err(), "nothing left to undo");
}
#[test]
fn polygon_fill_and_color_picker() {
let mut s = session();
execute(&mut s, "tool.material", &json!({"channel": "roughness", "value": 0.9})).unwrap();
execute(&mut s, "tool.polygonFill", &Value::Null).unwrap();
execute(&mut s, "tool.fillMode", &json!({"mode": "mesh"})).unwrap();
execute(&mut s, "tool.click", &json!({"x": 200, "y": 200})).unwrap();
execute(&mut s, "tool.colorPicker", &Value::Null).unwrap();
let r = execute(&mut s, "tool.click", &json!({"x": 200, "y": 200})).unwrap();
assert!((r["roughness"][0].as_f64().unwrap() - 0.9).abs() < 0.01, "{r}");
}
#[test]
fn polygon_fill_boxes_survive_hostile_params() {
let hostile = [
json!({"x0": 1e30, "y0": -1e30, "x1": f64::MAX, "y1": 0, "viewport": [1e9, 1e9]}),
json!({"x0": 0, "y0": 0, "x1": 0, "y1": 0, "viewport": [16, 16]}),
json!({"uv0": [1e30, -1e30], "uv1": [0, 0]}),
json!({"uv0": [0.5], "uv1": "x", "uv": [f64::MIN, 2]}),
json!({"hitTest": "nope", "visibleOnly": "yes", "mode": 7}),
];
for visible_only in [true, false] {
for hit_test in ["intersection", "containedCenter"] {
let mut session = session();
execute(&mut session, "tool.polygonFill", &Value::Null).unwrap();
execute(&mut session, "tool.fillSelection", &json!({"hitTest": hit_test, "visibleOnly": visible_only})).unwrap();
for params in &hostile {
let _ = execute(&mut session, "tool.click", params);
let _ = execute(&mut session, "tool.fillSelection", params);
session.update();
}
}
}
}
/// A small project still gets the production bake defaults; only panic_hunt overrides them.
#[test]
fn new_project_keeps_full_resolution_bake_defaults() {
let s = session();
assert!(!s.doc.project.texture_sets.is_empty());
for texture_set in &s.doc.project.texture_sets {
assert_eq!(texture_set.resolution, 256);
assert_eq!(texture_set.bake, texturecraft_engine::core::BakeSettings::default());
assert_eq!(texture_set.bake.common.output_size(), (2048, 2048));
assert_eq!(texture_set.bake.maps.ao.parameters.rays.rays, 64);
}
}
/// Every command must return Ok or Err — never panic — for hostile params.
#[test]
fn panic_hunt() {
let hostile = [
Value::Null,
json!({}),
json!({"layer": u64::MAX, "ts": 99, "channel": "nope", "mode": "???", "opacity": f64::MAX}),
json!({"layer": 1, "index": -5, "delta": i64::MIN, "above": "x", "points": [[f64::MAX, -1e300]], "size": -1e30}),
json!({"resolution": 0, "maps": ["x"], "rays": u64::MAX, "antialiasing": 3, "color": [1], "value": "nan"}),
json!({"effect": 0, "x": 1e30, "y": -1e30, "viewport": [0, 0], "mesh": "../../etc", "material": ""}),
];
for spec in command_specs() {
if spec.id == "project.sample" {
continue; // slow (bakes); covered elsewhere
}
for p in &hostile {
let mut s = session();
// Match the 256px fixture: otherwise empty/irrelevant bake.run params perform
// repeated 2048px default bakes. Keep every input, ray count and fresh session.
for texture_set in &mut s.doc.project.texture_sets {
texture_set.bake.common.resolution = texturecraft_engine::core::BakeResolution::R256;
}
let _ = execute(&mut s, spec.id, p);
s.update();
}
}
}
#[test]
fn copy_paste_flatten_and_resize_keep_the_look() {
let mut s = Session::new_project("t", primitives::material_ball(), "builtin:material_ball", None, 256).unwrap();
s.viewport = texturecraft_engine::geom::glam::Vec2::new(400.0, 400.0);
execute(&mut s, "layer.add.fill", &json!({"color": [0.9, 0.1, 0.1], "roughness": 0.3})).unwrap();
execute(&mut s, "mask.add.black", &Value::Null).unwrap();
execute(&mut s, "effect.add.fill", &json!({"procedural": "checker", "scale": 4})).unwrap();
s.update();
let before: Vec<[f32; 3]> = (0..256).step_by(9).map(|x| s.caches[0].composite.value(Channel::BaseColor, x, 100)).collect();
// Flatten keeps the composite identical (within 8-bit-ish tolerance) and makes a paint layer.
let id = s.selected_layer().unwrap();
execute(&mut s, "layer.flatten", &json!({"layer": id.0})).unwrap();
s.update();
let after: Vec<[f32; 3]> = (0..256).step_by(9).map(|x| s.caches[0].composite.value(Channel::BaseColor, x, 100)).collect();
for (a, b) in before.iter().zip(&after) {
for k in 0..3 {
assert!((a[k] - b[k]).abs() < 2e-3, "{a:?} {b:?}");
}
}
assert!(matches!(s.doc.project.layer(id).unwrap().kind, texturecraft_engine::core::LayerKind::Paint));
// Copy into the other texture set (different resolution).
execute(&mut s, "textureSet.resolution", &json!({"ts": 1, "resolution": 128})).unwrap();
execute(&mut s, "layer.copy", &Value::Null).unwrap();
execute(&mut s, "textureSet.select", &json!({"ts": 1})).unwrap();
let r = execute(&mut s, "layer.paste", &Value::Null).unwrap();
let pasted = texturecraft_engine::core::LayerId(r["layer"].as_u64().unwrap());
assert_eq!(s.doc.pixels.layer(pasted, Channel::BaseColor).unwrap().width(), 128);
// Resizing resamples instead of clearing.
execute(&mut s, "textureSet.resolution", &json!({"ts": 0, "resolution": 512})).unwrap();
assert_eq!(s.doc.pixels.layer(id, Channel::BaseColor).unwrap().width(), 512);
s.update();
let big = s.caches[0].composite.value(Channel::BaseColor, 2 * 9 * 5, 200);
let small = before[5];
assert!((big[0] - small[0]).abs() < 0.2, "{big:?} {small:?}");
execute(&mut s, "layer.instantiateAll", &json!({"layer": id.0})).unwrap();
s.doc.project.validate().unwrap();
}
#[test]
fn image_resources_fill_layers_and_round_trip() {
let mut s = session();
let mut png = Vec::new();
let img = image::RgbaImage::from_fn(8, 8, |_, _| image::Rgba([255, 0, 0, 255]));
img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
let name = s.import_resource_bytes("C:/x/red bricks.png", png).unwrap();
assert_eq!(name, "red_bricks.png");
let r = execute(&mut s, "layer.add.image", &json!({"name": name})).unwrap();
assert!(r["layer"].as_u64().is_some());
s.update();
let v = s.caches[0].composite.value(Channel::BaseColor, 128, 128);
assert!(v[0] > 0.95 && v[1] < 0.05, "{v:?}");
let bytes = s.to_project_bytes().unwrap();
let back = Session::from_project_bytes(&bytes).unwrap();
assert_eq!(back.doc.resources.len(), 1);
assert_eq!(back.images.len(), 1);
execute(&mut s, "edit.undo", &Value::Null).unwrap();
execute(&mut s, "edit.undo", &Value::Null).unwrap();
assert!(s.images.is_empty(), "undoing the import forgets the decoded image");
assert!(s.import_resource_bytes("bad.png", vec![1, 2, 3]).is_err());
}
#[test]
fn image_resource_lookup_accepts_extension_and_stem() {
let mut s = session();
// No resources imported yet
let err = execute(&mut s, "layer.add.image", &json!({"name": "missing"})).unwrap_err();
assert!(err.to_string().contains("no resource `missing` (no resources imported: use resource.import)"));
let mut png = Vec::new();
let img = image::RgbaImage::from_fn(4, 4, |_, _| image::Rgba([0, 255, 0, 255]));
img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
s.import_resource_bytes("tile.png", png.clone()).unwrap();
// Lookup by stem
let r = execute(&mut s, "layer.add.image", &json!({"name": "tile"})).unwrap();
assert!(r["layer"].as_u64().is_some());
// Lookup by full name
let r2 = execute(&mut s, "layer.add.image", &json!({"name": "tile.png"})).unwrap();
assert!(r2["layer"].as_u64().is_some());
// Missing resource lists available
let err = execute(&mut s, "layer.add.image", &json!({"name": "wood"})).unwrap_err();
assert!(err.to_string().contains("no resource `wood` (available: tile.png)"));
// Ambiguous stem resolution
s.import_resource_bytes("tile.jpg", png).unwrap();
let err = execute(&mut s, "layer.add.image", &json!({"name": "tile"})).unwrap_err();
assert!(err.to_string().contains("ambiguous resource `tile`"));
}
#[test]
fn image_resource_lookup_ignores_linked_packages() {
use std::sync::Arc;
use texturecraft_engine::core::{LayerId, LayerKind, Source};
let mut s = session();
s.doc.resources.insert("wood.mcraft".into(), Arc::new(b"package bytes".to_vec()));
s.sync_images();
assert!(!s.images.contains_key("wood.mcraft"));
let err = execute(&mut s, "layer.add.image", &json!({"name": "wood"})).unwrap_err();
assert!(err.to_string().contains("no resources imported"), "{err}");
let err = execute(&mut s, "layer.add.image", &json!({"name": "wood.mcraft"})).unwrap_err();
assert!(err.to_string().contains("no resource `wood.mcraft` (no resources imported"), "{err}");
let mut png = Vec::new();
let img = image::RgbaImage::from_fn(4, 4, |_, _| image::Rgba([0, 255, 0, 255]));
img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
s.import_resource_bytes("wood.png", png).unwrap();
let err = execute(&mut s, "layer.add.image", &json!({"name": "missing"})).unwrap_err();
assert!(err.to_string().contains("no resource `missing` (available: wood.png)"), "{err}");
let res = execute(&mut s, "layer.add.image", &json!({"name": "wood"})).unwrap();
let id = LayerId(res["layer"].as_u64().unwrap());
let LayerKind::Fill(fill) = &s.doc.project.layer(id).unwrap().kind else { panic!("expected fill layer") };
assert_eq!(fill.sources.get(&Channel::BaseColor), Some(&Source::image("wood.png")));
}
#[test]
fn brush_presets_apply_save_and_load() {
let mut s = session();
let list = execute(&mut s, "brush.preset.list", &Value::Null).unwrap();
assert!(list.as_array().unwrap().len() >= 12);
execute(&mut s, "tool.brush", &json!({"size": 30})).unwrap();
let b = execute(&mut s, "brush.preset.apply", &json!({"preset": "Scratches"})).unwrap();
assert_eq!((b["alpha"]["library"].as_str(), b["followPath"].as_bool()), (Some("scratches"), Some(true)));
assert!((b["size"].as_f64().unwrap() - 30.0).abs() < 1e-3, "presets keep the size");
assert!(execute(&mut s, "tool.stroke", &json!({"points": [[160, 200], [240, 200]]})).unwrap()["stamps"].as_u64().unwrap() > 0);
// Saved and loaded back onto another brush, the stroke returns and the size stays.
let path = std::env::temp_dir().join(format!("tc-brush-{}.tcbrush", std::process::id()));
let path = path.to_str().unwrap();
execute(&mut s, "brush.preset.save", &json!({"path": path})).unwrap();
execute(&mut s, "brush.preset.apply", &json!({"preset": "basic_soft"})).unwrap();
execute(&mut s, "tool.brush", &json!({"size": 10})).unwrap();
let b = execute(&mut s, "brush.preset.load", &json!({"path": path})).unwrap();
assert_eq!(b["alpha"]["library"], "scratches");
assert!((b["size"].as_f64().unwrap() - 10.0).abs() < 1e-3);
std::fs::write(path, b"{}").unwrap();
assert!(execute(&mut s, "brush.preset.load", &json!({"path": path})).is_err());
let _ = std::fs::remove_file(path);
for bad in [json!({}), json!({"preset": "nope"})] {
assert!(execute(&mut s, "brush.preset.apply", &bad).is_err());
}
}
#[test]
fn text_becomes_a_brush_alpha_and_a_decal() {
let mut s = session();
let fonts = execute(&mut s, "text.fonts", &Value::Null).unwrap();
assert_eq!(fonts["builtIn"][0], "Ubuntu Light");
let r = execute(&mut s, "resource.text", &json!({"text": "TEXT\nCRAFT", "font": "ubuntu light", "size": 64})).unwrap();
let name = r["name"].as_str().unwrap().to_string();
assert_eq!(name, "Text_TEXT.png");
assert!(r["width"].as_u64().unwrap() > r["height"].as_u64().unwrap() / 2, "two short lines");
// White with the glyphs in alpha.
let img = s.images[&name].clone();
assert!(img.rgba.iter().any(|t| t[3] > 0.99) && img.rgba.iter().any(|t| t[3] == 0.0) && img.rgba.iter().all(|t| t[0] == 1.0));
// As the brush alpha it paints (keeping its proportions), and it places as a decal.
execute(&mut s, "tool.material", &json!({"channel": "baseColor", "color": [1.0, 0.0, 0.0]})).unwrap();
execute(&mut s, "tool.brush", &json!({"size": 40, "alpha": {"image": name}})).unwrap();
assert!(execute(&mut s, "tool.click", &json!({"x": 200, "y": 200})).is_ok());
assert!(execute(&mut s, "layer.add.decal", &json!({"image": name})).unwrap()["layer"].as_u64().is_some());
for bad in [json!({}), json!({"text": " "}), json!({"text": "x", "font": "No Such Font"})] {
assert!(execute(&mut s, "resource.text", &bad).is_err(), "{bad}");
}
}
#[test]
fn projection_tool_paints_the_stencil_colors() {
let mut s = session();
let mut png = Vec::new();
let img = image::RgbaImage::from_fn(16, 16, |x, _| if x < 8 { image::Rgba([255, 0, 0, 255]) } else { image::Rgba([0, 255, 0, 255]) });
img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
let name = s.import_resource_bytes("split.png", png).unwrap();
execute(&mut s, "tool.projection", &Value::Null).unwrap();
// Without a stencil the tool explains what's missing.
assert!(execute(&mut s, "tool.stroke", &json!({"points": [[150, 200]]})).is_err());
execute(&mut s, "tool.stencil", &json!({"image": name, "scale": 1.0, "tile": true})).unwrap();
execute(&mut s, "tool.brush", &json!({"size": 6, "hardness": 90})).unwrap();
for x in [150.0f32, 250.0] {
execute(&mut s, "tool.stroke", &json!({"points": [[x, 200.0]]})).unwrap();
}
let vp = s.viewport;
let at = |s: &Session, x: f32| {
let hit = s.pick(texturecraft_engine::geom::glam::Vec2::new(x, 200.0), vp).unwrap();
s.caches[0].composite.value(Channel::BaseColor, (hit.uv.x * 256.0) as u32, (hit.uv.y * 256.0) as u32)
};
let left = at(&s, 150.0);
let right = at(&s, 250.0);
assert!(left[0] > 0.8 && left[1] < 0.2, "left {left:?}");
assert!(right[1] > 0.8 && right[0] < 0.2, "right {right:?}");
}
#[test]
fn smart_materials_save_and_load_with_pixels() {
let mut s = Session::new_project("t", primitives::material_ball(), "builtin:material_ball", None, 256).unwrap();
s.viewport = texturecraft_engine::geom::glam::Vec2::new(400.0, 400.0);
let group = texturecraft_engine::materials::apply(&mut s, "steel_painted_worn").unwrap();
let before = s.doc.project.walk(0).len();
let bytes = s.smart_material_bytes(group, "My Steel").unwrap();
execute(&mut s, "textureSet.select", &json!({"ts": 1})).unwrap();
let id = s.add_smart_material_bytes(&bytes).unwrap();
assert_eq!(s.doc.project.layer(id).unwrap().name, "My Steel");
let walked = s.doc.project.walk(1).len();
assert_eq!(walked, 1 + (before - 1), "the folder and its children arrive");
assert!(s.add_smart_material_bytes(b"junk").is_err());
s.doc.project.validate().unwrap();
}
/// Strokes drawn frame by frame (paint, erase, a mask) commit their staged tiles, which then
/// settle at low priority to exactly what a full recomposite gives; undo restores.
#[test]
fn committed_strokes_settle_to_the_full_composite() {
use texturecraft_engine::geom::glam::Vec2;
let mut s = Session::new_project("t", primitives::sphere(1.0, 48, 24), "builtin:sphere", None, 2048).unwrap();
s.viewport = Vec2::new(400.0, 400.0);
execute(&mut s, "layer.add.fill", &json!({"color": [0.2, 0.5, 0.3], "roughness": 0.7})).unwrap();
execute(&mut s, "layer.add.paint", &Value::Null).unwrap();
execute(&mut s, "tool.brush", &json!({"size": 25, "hardness": 70, "opacity": 0.8})).unwrap();
s.update();
let full = |s: &mut Session| {
s.caches[0].invalidate_all();
s.update();
s.caches[0].composite.clone()
};
let original = full(&mut s);
for step in ["paint", "eraser", "mask"] {
match step {
"eraser" => drop(execute(&mut s, "tool.select", &json!({"tool": "eraser"})).unwrap()),
"mask" => {
execute(&mut s, "tool.select", &json!({"tool": "paint"})).unwrap();
execute(&mut s, "mask.add.white", &Value::Null).unwrap();
s.target = texturecraft_engine::StackTarget::Mask;
s.tool.mask_value = 0.2;
}
_ => {}
}
s.update();
s.begin_stroke(Vec2::new(120.0, 200.0), s.viewport, 1.0).unwrap();
for i in 1..30 {
s.continue_stroke(Vec2::new(120.0 + i as f32 * 6.0, 200.0 + (i as f32 * 0.4).sin() * 40.0), 1.0);
s.update();
}
s.end_stroke().unwrap();
// Nothing was left dirty: the committed tiles only settle, a slice per budgeted update.
assert!(s.caches[0].dirty.is_empty(), "{step}");
let settling = s.caches[0].settle.len();
assert!(settling > 32, "{step}: {settling} tiles settle");
let t = std::cell::Cell::new(0.0);
let clock = || {
t.set(t.get() + 2.0);
t.get()
};
s.update_for(30.0, clock);
let left = s.pending_tiles();
assert!(left > 0 && left < settling, "{step}: {left} of {settling} left after one slice");
s.update();
let settled = s.caches[0].composite.clone();
assert_eq!(settled, full(&mut s), "{step}: settled tiles match a full recomposite");
}
// Mask stroke, white mask, eraser and paint strokes.
for _ in 0..4 {
execute(&mut s, "edit.undo", &Value::Null).unwrap();
}
assert_eq!(full(&mut s), original);
}
/// A resize prepared from a snapshot and applied later matches the command, keeps edits made
/// while it ran, and undoes in one step.
#[test]
fn background_resizes_match_the_command_and_keep_later_edits() {
use texturecraft_engine::bake::Progress;
let stroke = |s: &mut Session, y: u32| {
execute(s, "tool.stroke", &json!({"points": [[150, y], [250, y]]})).unwrap();
};
let (mut a, mut b) = (session(), session());
for s in [&mut a, &mut b] {
execute(s, "tool.brush", &json!({"size": 10})).unwrap();
stroke(s, 200);
}
execute(&mut a, "textureSet.resolution", &json!({"resolution": 512})).unwrap();
let task = b.resize_task(0, 512).unwrap();
let progress = Progress::new();
let out = task.run(&progress).unwrap();
assert_eq!(progress.fraction(), 1.0);
assert_eq!(out.target(), (0, 512));
b.apply_resize(out).unwrap();
assert_eq!(a.doc.pixels.layers, b.doc.pixels.layers);
a.update();
b.update();
assert_eq!(a.caches[0].composite, b.caches[0].composite);
assert_eq!(b.caches[0].size, (512, 512));
// A stroke painted while the resize ran is kept (the resize runs again on apply).
let out = b.resize_task(0, 1024).unwrap().run(&Progress::new()).unwrap();
stroke(&mut b, 260);
let painted = |s: &Session| s.doc.pixels.layers.values().map(|i| i.allocated_count()).sum::<usize>();
let before = painted(&b);
b.apply_resize(out).unwrap();
assert_eq!(b.doc.project.texture_sets[0].resolution, 1024);
stroke(&mut a, 260);
execute(&mut a, "textureSet.resolution", &json!({"resolution": 1024})).unwrap();
assert_eq!(a.doc.pixels.layers, b.doc.pixels.layers);
assert!(painted(&b) > before);
assert_eq!(b.undo_label(), Some("Texture set size"));
execute(&mut b, "edit.undo", &Value::Null).unwrap();
assert_eq!((b.doc.project.texture_sets[0].resolution, painted(&b)), (512, before));
b.update();
assert_eq!(b.caches[0].size, (512, 512));
}
/// A 2048 sphere set with a fill layer and an empty paint layer, a small brush, and the
/// oracle: the composite after recompositing every covered tile from scratch.
fn painted_set() -> Session {
use texturecraft_engine::geom::glam::Vec2;
let mut s = Session::new_project("t", primitives::sphere(1.0, 48, 24), "builtin:sphere", None, 2048).unwrap();
s.viewport = Vec2::new(400.0, 400.0);
execute(&mut s, "layer.add.fill", &json!({"color": [0.2, 0.5, 0.3], "roughness": 0.7})).unwrap();
execute(&mut s, "layer.add.paint", &Value::Null).unwrap();
execute(&mut s, "tool.brush", &json!({"size": 12, "hardness": 70, "opacity": 0.8})).unwrap();
// Seed the image so later strokes change existing tiles
execute(&mut s, "tool.stroke", &json!({"points": [[150, 160], [170, 170]]})).unwrap();
s.update();
s
}
fn full(s: &mut Session) -> texturecraft_engine::compose::Composite {
s.caches[0].invalidate_all();
s.update();
s.caches[0].composite.clone()
}
/// Undo and redo of `change` queue the right tiles: `Some(max)` fewer than `max` of them, matching
/// a full recomposite once updated; `None` every covered tile.
fn check_undo_redo(s: &mut Session, change: impl FnOnce(&mut Session), limit: Option<usize>) {
change(s);
s.update();
for cmd in ["edit.undo", "edit.redo"] {
execute(s, cmd, &Value::Null).unwrap();
let (dirty, covered) = (s.caches[0].dirty.len(), s.caches[0].covered_tiles.len());
match limit {
Some(max) => assert!(0 < dirty && dirty < max, "{cmd}: {dirty} of {covered} tiles dirty"),
None => assert_eq!(dirty, covered, "{cmd}"),
}
s.update();
let settled = s.caches[0].composite.clone();
assert_eq!(settled, full(s), "{cmd}: matches a full recomposite");
}
}
#[test]
fn undo_recomposites_only_changed_tiles() {
let mut s = painted_set();
let stroke = |s: &mut Session| drop(execute(s, "tool.stroke", &json!({"points": [[150, 200], [190, 210]]})).unwrap());
// The stroke covers a handful of the set's 1024 tiles
check_undo_redo(&mut s, stroke, Some(64));
}
#[test]
fn undo_with_a_blur_above_recomposites_everything() {
use texturecraft_engine::geom::glam::Vec2;
let mut s = Session::new_project("t", primitives::sphere(1.0, 48, 24), "builtin:sphere", None, 2048).unwrap();
s.viewport = Vec2::new(400.0, 400.0);
execute(&mut s, "layer.add.fill", &json!({"color": [0.2, 0.5, 0.3], "roughness": 0.7})).unwrap();
execute(&mut s, "mask.add.white", &Value::Null).unwrap();
execute(&mut s, "effect.add.filter", &json!({"filter": "blur", "radius": 8})).unwrap();
execute(&mut s, "layer.add.paint", &Value::Null).unwrap();
execute(&mut s, "tool.brush", &json!({"size": 12, "hardness": 70, "opacity": 0.8})).unwrap();
execute(&mut s, "tool.stroke", &json!({"points": [[150, 160], [170, 170]]})).unwrap();
s.update();
let stroke = |s: &mut Session| drop(execute(s, "tool.stroke", &json!({"points": [[150, 200], [190, 210]]})).unwrap());
check_undo_redo(&mut s, stroke, None);
}
#[test]
fn polygon_fill_recomposites_only_changed_tiles() {
let mut s = painted_set();
execute(&mut s, "tool.material", &json!({"channel": "roughness", "value": 0.1})).unwrap();
execute(&mut s, "tool.stroke", &json!({"points": [[150, 240], [170, 250]]})).unwrap();
execute(&mut s, "tool.polygonFill", &Value::Null).unwrap();
s.update();
let tris = s.polygon_fill(texturecraft_engine::geom::glam::Vec2::new(200.0, 200.0), s.viewport).unwrap();
assert!(tris > 0);
let (dirty, covered) = (s.caches[0].dirty.len(), s.caches[0].covered_tiles.len());
assert!(0 < dirty && dirty < covered / 4, "{dirty} of {covered} tiles dirty after one triangle");
s.update();
let settled = s.caches[0].composite.clone();
assert_eq!(settled, full(&mut s));
execute(&mut s, "edit.undo", &Value::Null).unwrap();
assert!(s.caches[0].dirty.len() < covered / 4);
s.update();
let settled = s.caches[0].composite.clone();
assert_eq!(settled, full(&mut s));
}
#[test]
fn undo_of_a_layer_change_recomposites_everything() {
let mut s = painted_set();
let change = |s: &mut Session| drop(execute(s, "layer.blend", &json!({"channel": "all", "opacity": 0.5})).unwrap());
check_undo_redo(&mut s, change, None);
}
#[test]
fn curvature_generators_take_a_mode_and_detail_sizes() {
let mut state = session();
execute(&mut state, "layer.add.fill", &json!({})).unwrap();
execute(&mut state, "mask.add.black", &Value::Null).unwrap();
let added = execute(&mut state, "effect.add.generator", &json!({"generator": "curvature", "mode": "cavities"})).unwrap();
let effect = added["effect"].clone();
execute(&mut state, "effect.set", &json!({"effect": effect, "sizes": [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.5]})).unwrap();
let inspect = execute(&mut state, "project.inspect", &Value::Null).unwrap().to_string();
assert!(inspect.contains(r#""mode":"Cavities""#) && inspect.contains(r#""sizes":[0.0,0.0,0.0,1.0,0.0,0.0,0.5]"#), "{inspect}");
let too_few = execute(&mut state, "effect.set", &json!({"effect": effect, "sizes": [1.0, 0.5]}));
assert!(too_few.is_err(), "sizes takes one weight per detail size");
let not_numbers = execute(&mut state, "effect.set", &json!({"effect": effect, "sizes": [1.0, "a", 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]}));
assert!(not_numbers.is_err(), "a size that isn't a number is rejected, not skipped");
let unknown = execute(&mut state, "effect.set", &json!({"effect": effect, "mode": "ridges"}));
assert!(unknown.is_err(), "unknown modes are rejected");
let wrong_type = execute(&mut state, "effect.set", &json!({"effect": effect, "mode": 1, "level": 0.1}));
assert!(wrong_type.is_err(), "a mode must be a string and an invalid edit must be rejected");
let dirt = execute(&mut state, "effect.add.generator", &json!({"generator": "dirt", "mode": "edges"}));
assert!(dirt.is_err(), "only curvature generators have a mode");
assert_eq!(execute(&mut state, "project.inspect", &Value::Null).unwrap().to_string(), inspect, "failed commands leave the project unchanged");
}
#[test]
fn generators_take_blur_balance_and_contrast() {
let mut state = session();
execute(&mut state, "layer.add.fill", &json!({})).unwrap();
execute(&mut state, "mask.add.black", &Value::Null).unwrap();
let added = execute(&mut state, "effect.add.generator", &json!({"generator": "dirt", "blur": 0.25})).unwrap();
let effect = added["effect"].clone();
execute(&mut state, "effect.set", &json!({"effect": effect, "balance": 0.75, "contrast": 2.0})).unwrap();
let inspect = execute(&mut state, "project.inspect", &Value::Null).unwrap().to_string();
assert!(inspect.contains(r#""blur":0.25"#) && inspect.contains(r#""balance":0.75"#), "{inspect}");
assert!(inspect.contains(r#""contrast":1.0"#), "contrast is clamped to 0..1: {inspect}");
execute(&mut state, "effect.set", &json!({"effect": effect, "resolution": "custom", "customResolution": 512, "resolutionFactor": -9})).unwrap();
let inspect = execute(&mut state, "project.inspect", &Value::Null).unwrap().to_string();
assert!(inspect.contains(r#""resolution":{"custom":512,"factor":-3,"mode":"Custom"}"#), "the factor is clamped to 1/8: {inspect}");
assert!(execute(&mut state, "effect.set", &json!({"effect": effect, "resolution": "huge"})).is_err(), "unknown resolutions are rejected");
}
#[test]
fn a_generator_input_reads_a_uniform_value_or_its_mesh_map_again() {
let mut state = session();
execute(&mut state, "layer.add.fill", &json!({})).unwrap();
execute(&mut state, "mask.add.black", &Value::Null).unwrap();
let effect = execute(&mut state, "effect.add.generator", &json!({"generator": "dirt"})).unwrap()["effect"].clone();
execute(&mut state, "effect.set", &json!({"effect": effect, "input": "ambientOcclusion", "inputValue": 0.25})).unwrap();
let inspect = execute(&mut state, "project.inspect", &Value::Null).unwrap().to_string();
assert!(inspect.contains(r#""inputs":{"ambientOcclusion":{"uniform":[0.25,0.25,0.25]}}"#), "{inspect}");
let wrong_input = execute(&mut state, "effect.set", &json!({"effect": effect, "input": "curvature", "inputValue": 0.5}));
assert!(wrong_input.is_err(), "dirt reads ambient occlusion, not curvature");
let missing_image = execute(&mut state, "effect.set", &json!({"effect": effect, "input": "ambientOcclusion", "inputImage": "nothing.png"}));
assert!(missing_image.is_err(), "the image must be a resource of the project");
let two_sources = execute(&mut state, "effect.set", &json!({"effect": effect, "input": "ambientOcclusion", "inputValue": 0.5, "inputBaked": true}));
assert!(two_sources.is_err(), "an input takes one source");
execute(&mut state, "effect.set", &json!({"effect": effect, "input": "ambientOcclusion", "inputBaked": true})).unwrap();
let inspect = execute(&mut state, "project.inspect", &Value::Null).unwrap().to_string();
assert!(!inspect.contains(r#""inputs""#), "the mesh map is read again: {inspect}");
}
#[test]
fn changing_generator_kind_keeps_the_effect_identity_and_settings() {
let mut state = session();
execute(&mut state, "layer.add.fill", &json!({})).unwrap();
execute(&mut state, "mask.add.black", &Value::Null).unwrap();
let effect = execute(&mut state, "effect.add.generator", &json!({"generator": "dirt"})).unwrap()["effect"].as_u64().unwrap();
execute(&mut state, "effect.set", &json!({"effect": effect, "name": "Keep me", "opacity": 0.4, "level": 0.2})).unwrap();
execute(&mut state, "effect.set", &json!({"effect": effect, "input": "ambientOcclusion", "inputValue": 0.25})).unwrap();
let later = execute(&mut state, "effect.add.generator", &json!({"generator": "position"})).unwrap()["effect"].as_u64().unwrap();
execute(&mut state, "effect.set", &json!({"effect": effect, "generator": "ambientOcclusion"})).unwrap();
let (owner, edited) = state.doc.project.effect(texturecraft_core::LayerId(effect)).unwrap();
assert!(matches!(&edited.kind, texturecraft_core::EffectKind::Generator(generator)
if generator.kind == texturecraft_core::GeneratorKind::AmbientOcclusion
&& generator.level == 0.2
&& matches!(generator.inputs.get(&texturecraft_core::BakedMap::AmbientOcclusion), Some(texturecraft_core::Source::Uniform([0.25, 0.25, 0.25])))));
assert_eq!(edited.name, "Keep me");
assert_eq!(edited.opacity, 0.4);
let layer = state.doc.project.layer(owner).unwrap();
let ids: Vec<u64> = layer.mask.as_ref().unwrap().effects.iter().map(|item| item.id.0).collect();
assert_eq!(ids, vec![effect, later]);
}
#[test]
fn unparseable_color_param_returns_error() {
let mut s = session();
let err = execute(&mut s, "layer.add.fill", &json!({"color": "#fff"})).unwrap_err();
assert_eq!(err.to_string(), "`layer.add.fill`: `color` must be a color ([r, g, b] linear or \"#rrggbb\")");
let err = execute(&mut s, "layer.fill.set", &json!({"channel": "baseColor", "color": "#123"})).unwrap_err();
assert_eq!(err.to_string(), "`layer.fill.set`: `color` must be a color ([r, g, b] linear or \"#rrggbb\")");
let err = execute(&mut s, "tool.material", &json!({"channel": "baseColor", "color": "invalid"})).unwrap_err();
assert_eq!(err.to_string(), "`tool.material`: `color` must be a color ([r, g, b] linear or \"#rrggbb\")");
let err = execute(&mut s, "mask.add.colorSelection", &json!({"color": "#xyz"})).unwrap_err();
assert_eq!(err.to_string(), "`mask.add.colorSelection`: `color` must be a color ([r, g, b] linear or \"#rrggbb\")");
let err = execute(&mut s, "display.set", &json!({"scatterColor": "#12345"})).unwrap_err();
assert_eq!(err.to_string(), "`display.set`: `scatterColor` must be a color ([r, g, b] linear or \"#rrggbb\")");
let rev_before = s.revision;
let exposure_before = s.doc.project.display.env_exposure;
let err = execute(&mut s, "display.set", &json!({"exposure": 2.0, "scatterColor": "invalid"})).unwrap_err();
assert_eq!(err.to_string(), "`display.set`: `scatterColor` must be a color ([r, g, b] linear or \"#rrggbb\")");
assert_eq!(s.doc.project.display.env_exposure, exposure_before);
assert_eq!(s.revision, rev_before);
let mask_before = s.tool.mask_value;
let err = execute(&mut s, "tool.material", &json!({"maskValue": 0.25, "channel": "baseColor", "color": "invalid"})).unwrap_err();
assert_eq!(err.to_string(), "`tool.material`: `color` must be a color ([r, g, b] linear or \"#rrggbb\")");
assert_eq!(s.tool.mask_value, mask_before);
assert_eq!(s.revision, rev_before);
let err = execute(&mut s, "tool.material", &json!({"color": "invalid"})).unwrap_err();
assert_eq!(err.to_string(), "`tool.material`: `color` must be a color ([r, g, b] linear or \"#rrggbb\")");
assert_eq!(s.revision, rev_before);
let err = execute(&mut s, "layer.add.fill", &json!({"color": [1e40, 0.0, 0.0]})).unwrap_err();
assert_eq!(err.to_string(), "`layer.add.fill`: `color` must be a color ([r, g, b] linear or \"#rrggbb\")");
assert_eq!(s.revision, rev_before);
let err = execute(&mut s, "layer.fill.set", &json!({"channel": "baseColor", "procedural": "noise", "color": "red"})).unwrap_err();
assert_eq!(err.to_string(), "`layer.fill.set`: `color` must be a color ([r, g, b] linear or \"#rrggbb\")");
assert_eq!(s.revision, rev_before);
assert!(execute(&mut s, "tool.cloneSource", &json!({"uv": [0.2, 0.8, 0.4]})).is_err());
execute(&mut s, "tool.polygonFill", &Value::Null).unwrap();
let err = execute(&mut s, "tool.click", &json!({"uv": [0.2, 0.8, 0.4]})).unwrap_err();
assert_eq!(err.to_string(), "`tool.click`: a 2D view point needs `uv` as [u, v]");
}