mirror of
https://github.com/storytold/texturecraft.git
synced 2026-11-19 14:00:43 +01:00
429 lines
18 KiB
Rust
429 lines
18 KiB
Rust
//! Live bake preview: maps stream into the view while a bake runs, the view mode comes back,
|
|
//! painting is paused, a cancelled bake leaves the set it was baking alone (sets finished before it
|
|
//! stay applied), the streamed pixels are the ones a single bake makes, and the preview and the
|
|
//! document share each map's buffer instead of holding two copies.
|
|
|
|
use serde_json::{Value, json};
|
|
use texturecraft_engine::bake::Progress;
|
|
use texturecraft_engine::core::{BakeResolution, BakedMap, Channel};
|
|
use texturecraft_engine::geom::glam::Vec2;
|
|
use texturecraft_engine::{BakeTask, PreviewShow, Session, ViewMode, execute};
|
|
|
|
const MAPS: [BakedMap; 4] = [BakedMap::Id, BakedMap::AmbientOcclusion, BakedMap::Curvature, BakedMap::Height];
|
|
|
|
fn session() -> Session {
|
|
let mut session = texturecraft_engine::sample_session(256, 64).unwrap();
|
|
for texture_set in &mut session.doc.project.texture_sets {
|
|
texture_set.bake = Default::default();
|
|
texture_set.bake.common.resolution = BakeResolution::R64;
|
|
texture_set.bake.maps.ao.parameters.rays.rays = 8;
|
|
texture_set.bake.maps.select(MAPS);
|
|
}
|
|
|
|
session
|
|
}
|
|
|
|
fn task(session: &Session) -> BakeTask {
|
|
let mut task = session.bake_task(0).unwrap();
|
|
task.tracer = None;
|
|
task
|
|
}
|
|
|
|
fn order(session: &Session) -> Vec<BakedMap> {
|
|
task(session).maps()
|
|
}
|
|
|
|
#[test]
|
|
fn streamed_maps_are_the_pixels_of_one_bake() {
|
|
let session = session();
|
|
let task = task(&session);
|
|
let whole = task.run(&Progress::new()).unwrap();
|
|
let mut streamed = Vec::new();
|
|
|
|
let combined = task.run_streaming(&Progress::new(), &mut |map| streamed.push(map)).unwrap();
|
|
|
|
assert_eq!(streamed.iter().map(|map| map.map).collect::<Vec<_>>(), order(&session));
|
|
assert_eq!(streamed.iter().map(|map| (map.index, map.total)).collect::<Vec<_>>(), (0..MAPS.len()).map(|index| (index, MAPS.len())).collect::<Vec<_>>());
|
|
assert_eq!((combined.resolution, combined.height), (whole.resolution, whole.height));
|
|
assert_eq!(combined.maps.keys().collect::<Vec<_>>(), whole.maps.keys().collect::<Vec<_>>());
|
|
for (map, pixels) in &whole.maps {
|
|
assert!(*combined.maps[map] == *pixels, "{map:?} differs between a streamed and a single bake");
|
|
}
|
|
for map in &streamed {
|
|
assert!(*map.data == whole.maps[&map.map], "{:?} handed over differs from the bake", map.map);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn the_view_follows_each_map_and_the_previous_mode_comes_back() {
|
|
let mut session = session();
|
|
session.view = ViewMode::Channel(Channel::Roughness);
|
|
let before = session.view;
|
|
let baked_before = session.doc.baked.get(&0).cloned();
|
|
let maps = order(&session);
|
|
|
|
session.bake_preview_begin(vec![(0, maps.clone())]);
|
|
session.bake_preview_set_current(0);
|
|
|
|
// Nothing is baked yet: the first map shows, neutral
|
|
assert_eq!(session.view, ViewMode::MeshMap(maps[0]));
|
|
assert!(session.bake_preview_baked(0).is_some_and(|baked| baked.maps.is_empty()));
|
|
|
|
let task = task(&session);
|
|
let mut shown = Vec::new();
|
|
let mut stages = Vec::new();
|
|
let output = task
|
|
.run_streaming(&Progress::new(), &mut |map| {
|
|
session.bake_preview_map(0, map);
|
|
shown.push(session.view);
|
|
stages.push(session.bake_preview.as_ref().and_then(|preview| preview.stage()).map(|stage| (stage.position, stage.total)));
|
|
})
|
|
.unwrap();
|
|
|
|
assert_eq!(shown, maps.iter().map(|map| ViewMode::MeshMap(*map)).collect::<Vec<_>>(), "the view follows the newest map");
|
|
assert_eq!(stages, [Some((2, 4)), Some((3, 4)), Some((4, 4)), None], "the stage names the next map");
|
|
assert_eq!(session.doc.baked.get(&0).cloned(), baked_before, "the document is untouched until the bake is applied");
|
|
let undo_before = session.undo_label().map(str::to_owned);
|
|
|
|
session.apply_streamed_bake(0, output).unwrap();
|
|
assert_ne!(session.undo_label().map(str::to_owned), undo_before, "applying the bake is one undo step");
|
|
session.bake_preview_end();
|
|
|
|
assert_eq!(session.view, before, "the previous view mode is restored");
|
|
assert!(!session.bake_preview_active());
|
|
assert!(maps.iter().all(|map| session.doc.baked[&0].maps.contains_key(map)));
|
|
}
|
|
|
|
#[test]
|
|
fn pinning_material_and_follow() {
|
|
let mut session = session();
|
|
let maps = order(&session);
|
|
|
|
session.bake_preview_begin(vec![(0, maps.clone())]);
|
|
session.bake_preview_set_current(0);
|
|
let task = task(&session);
|
|
let mut count = 0;
|
|
|
|
task.run_streaming(&Progress::new(), &mut |map| {
|
|
session.bake_preview_map(0, map);
|
|
count += 1;
|
|
match count {
|
|
// Pin the finished map: later maps do not take the view
|
|
1 => session.bake_preview_show(PreviewShow::Pin(maps[0])).unwrap(),
|
|
2 => {
|
|
assert_eq!(session.view, ViewMode::MeshMap(maps[0]));
|
|
session.bake_preview_show(PreviewShow::Material).unwrap();
|
|
}
|
|
3 => {
|
|
assert_eq!(session.view, ViewMode::Material);
|
|
session.bake_preview_show(PreviewShow::Follow).unwrap();
|
|
assert_eq!(session.view, ViewMode::MeshMap(maps[2]));
|
|
}
|
|
_ => {}
|
|
}
|
|
})
|
|
.unwrap();
|
|
|
|
// A mesh map picked in the viewport pins it; another mode is what comes back at the end
|
|
execute(&mut session, "viewport.view", &json!({ "mode": "map:height" })).unwrap();
|
|
assert_eq!(session.bake_preview.as_ref().map(|preview| preview.show), Some(PreviewShow::Pin(BakedMap::Height)));
|
|
execute(&mut session, "viewport.view", &json!({ "mode": "uvChecker" })).unwrap();
|
|
assert_eq!(session.view, ViewMode::UvChecker);
|
|
session.bake_preview_end();
|
|
|
|
assert_eq!(session.view, ViewMode::UvChecker);
|
|
}
|
|
|
|
#[test]
|
|
fn unbaked_sets_show_neutral_and_the_control_command_reports() {
|
|
let mut session = session();
|
|
assert_eq!(execute(&mut session, "bake.preview", &Value::Null).unwrap()["active"], false);
|
|
assert!(execute(&mut session, "bake.preview", &json!({ "show": "material" })).is_err(), "nothing to show when no bake runs");
|
|
|
|
session.bake_preview_begin(vec![(0, order(&session)), (1, order(&session))]);
|
|
session.bake_preview_set_current(0);
|
|
|
|
assert!(session.bake_preview_baked(1).is_some_and(|baked| baked.maps.is_empty()), "a queued set has nothing yet");
|
|
assert!(session.bake_preview_baked(7).is_none(), "a set outside the bake shows its document maps");
|
|
let reply = execute(&mut session, "bake.preview", &json!({ "show": "map:ambientOcclusion" })).unwrap();
|
|
|
|
assert_eq!(
|
|
(reply["active"].clone(), reply["show"].clone(), reply["shown"].clone()),
|
|
(json!(true), json!("map:ambientOcclusion"), json!("ambientOcclusion"))
|
|
);
|
|
assert!(execute(&mut session, "bake.preview", &json!({ "show": "nonsense" })).is_err());
|
|
assert_eq!(texturecraft_engine::inspect::session(&session)["bakePreview"]["active"], true);
|
|
}
|
|
|
|
#[test]
|
|
fn painting_is_refused_while_a_bake_shows() {
|
|
let mut session = session();
|
|
session.bake_preview_begin(vec![(0, order(&session))]);
|
|
|
|
let error = session.begin_stroke(Vec2::new(10.0, 10.0), Vec2::new(100.0, 100.0), 1.0).unwrap_err().to_string();
|
|
|
|
assert_eq!(error, texturecraft_engine::bake_preview::PAINTING_PAUSED);
|
|
assert!(session.begin_stroke_uv(Vec2::new(0.5, 0.5), 1.0).is_err());
|
|
assert!(session.polygon_fill(Vec2::new(10.0, 10.0), Vec2::new(100.0, 100.0)).is_err());
|
|
assert!(!session.stroke_active());
|
|
session.bake_preview_end();
|
|
assert!(session.painting_blocked().is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn cancelling_mid_bake_leaves_the_document_and_the_shown_maps_whole() {
|
|
let mut session = session();
|
|
let before = session.doc.baked.get(&0).cloned();
|
|
let maps = order(&session);
|
|
let full = task(&session).run(&Progress::new()).unwrap();
|
|
session.bake_preview_begin(vec![(0, maps.clone())]);
|
|
session.bake_preview_set_current(0);
|
|
let progress = Progress::new();
|
|
let task = task(&session);
|
|
|
|
let result = task.run_streaming(&progress, &mut |map| {
|
|
if map.index == 1 {
|
|
progress.cancel();
|
|
}
|
|
session.bake_preview_map(0, map);
|
|
});
|
|
|
|
assert!(result.is_err(), "a cancelled bake fails");
|
|
|
|
// The two maps that landed are whole and equal to a full bake's; the others are still neutral
|
|
let shown = session.bake_preview_baked(0).unwrap();
|
|
assert_eq!(shown.maps.len(), 2);
|
|
for (map, data) in &shown.maps {
|
|
assert!(**data == full.maps[map], "{map:?}");
|
|
}
|
|
|
|
// What the app does on cancel: end the preview; the document keeps what it had
|
|
session.bake_preview_end();
|
|
|
|
assert_eq!(session.doc.baked.get(&0).cloned(), before);
|
|
assert!(session.bake_preview_baked(0).is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn the_preview_and_the_applied_document_share_each_map_buffer() {
|
|
let mut session = session();
|
|
let maps = order(&session);
|
|
|
|
session.bake_preview_begin(vec![(0, maps)]);
|
|
session.bake_preview_set_current(0);
|
|
let mut handed_over = Vec::new();
|
|
|
|
let output = task(&session)
|
|
.run_streaming(&Progress::new(), &mut |map| {
|
|
handed_over.push((map.map, map.data.clone()));
|
|
session.bake_preview_map(0, map);
|
|
})
|
|
.unwrap();
|
|
|
|
// Sharing the streamed buffers keeps preview memory independent of document ownership
|
|
for (map, data) in &handed_over {
|
|
assert!(std::sync::Arc::ptr_eq(data, &output.maps[map]), "{map:?} was copied on the way out of the bake");
|
|
let shown = &session.bake_preview_baked(0).unwrap().maps[map];
|
|
assert!(std::sync::Arc::ptr_eq(data, shown), "{map:?} is held twice by the preview");
|
|
}
|
|
|
|
// Applying the result must preserve sharing with the preview
|
|
session.apply_streamed_bake(0, output).unwrap();
|
|
for (map, data) in &handed_over {
|
|
assert!(std::sync::Arc::ptr_eq(data, &session.doc.baked[&0].maps[map]), "{map:?} was copied into the document");
|
|
}
|
|
session.bake_preview_end();
|
|
}
|
|
|
|
#[test]
|
|
fn cancelling_keeps_a_set_that_was_already_applied_as_one_undo_step() {
|
|
let mut session = session();
|
|
let before = session.doc.baked.get(&0).cloned();
|
|
let maps = order(&session);
|
|
|
|
// A multi-set bake applies each set when it finishes; a later cancel does not undo it
|
|
session.bake_preview_begin(vec![(0, maps)]);
|
|
session.bake_preview_set_current(0);
|
|
let output = task(&session)
|
|
.run_streaming(&Progress::new(), &mut |map| {
|
|
session.bake_preview_map(0, map);
|
|
})
|
|
.unwrap();
|
|
session.apply_streamed_bake(0, output).unwrap();
|
|
session.bake_preview_end();
|
|
|
|
assert!(MAPS.iter().all(|map| session.doc.baked[&0].maps.contains_key(map)), "the finished set stays baked after the cancel");
|
|
session.undo().unwrap();
|
|
assert_eq!(session.doc.baked.get(&0).cloned(), before, "applying the set was one undo step");
|
|
}
|
|
|
|
#[test]
|
|
fn a_resized_partial_streamed_bake_keeps_unchecked_maps() {
|
|
use std::sync::Arc;
|
|
use texturecraft_engine::compose::BakedMaps;
|
|
use texturecraft_engine::geom::primitives;
|
|
|
|
let mut session = Session::new_project("Partial bake", primitives::udim_plane(), "builtin:udim_plane", None, 128).unwrap();
|
|
session.doc.baked.insert(
|
|
0,
|
|
BakedMaps {
|
|
resolution: 64,
|
|
maps: [
|
|
(BakedMap::AmbientOcclusion, Arc::new(vec![0.25; 64 * 32])),
|
|
(BakedMap::Normal, Arc::new(vec![0.4; 64 * 32 * 3])),
|
|
(BakedMap::Height, Arc::new(vec![0.75; 64 * 32])),
|
|
]
|
|
.into(),
|
|
},
|
|
);
|
|
execute(&mut session, "bake.settings", &json!({"resolution": 64, "maps": ["ambientOcclusion", "height"], "rays": 2})).unwrap();
|
|
execute(&mut session, "bake.tile.set", &json!({"tile": 1002, "enabled": false})).unwrap();
|
|
let before = session.doc.baked.clone();
|
|
let task = task(&session);
|
|
let whole = task.run(&Progress::new()).unwrap();
|
|
let mut streamed = Vec::new();
|
|
|
|
let output = task.run_streaming(&Progress::new(), &mut |map| streamed.push(map)).unwrap();
|
|
|
|
assert_eq!((output.resolution, output.height), (128, 64));
|
|
assert_eq!(output.maps.keys().collect::<Vec<_>>(), whole.maps.keys().collect::<Vec<_>>());
|
|
for (map, pixels) in &whole.maps {
|
|
assert_eq!(*output.maps[map], *pixels, "{map:?} must match a whole bake, including retained pixels");
|
|
}
|
|
assert_eq!(streamed.iter().map(|map| map.map).collect::<Vec<_>>(), [BakedMap::AmbientOcclusion, BakedMap::Height]);
|
|
for map in &streamed {
|
|
assert!(Arc::ptr_eq(&map.data, &output.maps[&map.map]));
|
|
}
|
|
|
|
session.apply_streamed_bake(0, output).unwrap();
|
|
|
|
for (map, pixels) in &whole.maps {
|
|
assert_eq!(*session.doc.baked[&0].maps[map], *pixels);
|
|
}
|
|
session.undo().unwrap();
|
|
assert_eq!(session.doc.baked, before);
|
|
}
|
|
|
|
#[test]
|
|
fn box_fills_are_refused_while_a_bake_shows() {
|
|
let mut session = session();
|
|
execute(&mut session, "layer.add.paint", &Value::Null).unwrap();
|
|
execute(&mut session, "tool.polygonFill", &Value::Null).unwrap();
|
|
session.bake_preview_begin(vec![(0, order(&session))]);
|
|
let before = texturecraft_engine::inspect::session(&session);
|
|
let viewport = Vec2::new(100.0, 100.0);
|
|
|
|
for result in [
|
|
session.drag_polygon_fill_box_uv(Vec2::ZERO, Vec2::ONE),
|
|
session.drag_polygon_fill_box(Vec2::ZERO, viewport, viewport),
|
|
session.polygon_fill_box_uv(Vec2::ZERO, Vec2::ONE),
|
|
session.polygon_fill_box(Vec2::ZERO, viewport, viewport),
|
|
execute(&mut session, "tool.click", &json!({"uv0": [0, 0], "uv1": [1, 1]})).map(|_| 0),
|
|
execute(&mut session, "tool.click", &json!({"x0": 0, "y0": 0, "x1": 100, "y1": 100})).map(|_| 0),
|
|
] {
|
|
assert_eq!(result.unwrap_err().to_string(), texturecraft_engine::bake_preview::PAINTING_PAUSED);
|
|
}
|
|
|
|
assert_eq!(session.end_polygon_fill_box(), 0);
|
|
assert_eq!(texturecraft_engine::inspect::session(&session), before);
|
|
session.bake_preview_end();
|
|
assert!(session.polygon_fill_box_uv(Vec2::ZERO, Vec2::ONE).unwrap() > 0);
|
|
}
|
|
|
|
#[test]
|
|
fn preview_order_matches_each_sets_bake_task() {
|
|
let mut session = session();
|
|
session.doc.project.texture_sets[1].bake.maps.select([BakedMap::WorldNormal, BakedMap::Height]);
|
|
let expected: Vec<_> = [0, 1].into_iter().map(|texture_set| session.bake_task(texture_set).unwrap().maps()).collect();
|
|
|
|
session.bake_preview_begin_for(&[0, 1]).unwrap();
|
|
|
|
let preview = session.bake_preview.as_ref().unwrap();
|
|
for (texture_set, maps) in expected.iter().enumerate() {
|
|
assert_eq!(&preview.sets[&texture_set].order, maps);
|
|
assert!(preview.sets[&texture_set].baked.maps.is_empty());
|
|
}
|
|
assert_eq!(session.view, ViewMode::MeshMap(expected[0][0]));
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_preview_sets_preserve_the_existing_preview_and_view() {
|
|
let mut session = session();
|
|
session.bake_preview_begin_for(&[0]).unwrap();
|
|
session.bake_preview_set_current(0);
|
|
session.bake_preview_show(PreviewShow::Material).unwrap();
|
|
let before = texturecraft_engine::bake_preview::preview_json(&session);
|
|
let view = session.view;
|
|
let revision = session.revision;
|
|
let invalid_set = session.set_count();
|
|
let expected_error = session.doc.project.texture_set(invalid_set).unwrap_err().to_string();
|
|
|
|
let error = session.bake_preview_begin_for(&[1, invalid_set]).unwrap_err();
|
|
|
|
assert!(error.to_string().contains(&expected_error));
|
|
assert_eq!(texturecraft_engine::bake_preview::preview_json(&session), before);
|
|
assert_eq!(session.view, view);
|
|
assert_eq!(session.revision, revision);
|
|
}
|
|
|
|
#[test]
|
|
fn starting_a_bake_preview_discards_an_active_stroke() {
|
|
for (from_settings, paint_mask) in [(false, false), (true, false), (false, true), (true, true)] {
|
|
let mut session = session();
|
|
execute(&mut session, "layer.add.paint", &Value::Null).unwrap();
|
|
if paint_mask {
|
|
session.target = texturecraft_engine::StackTarget::Mask;
|
|
}
|
|
|
|
let before = session.doc.clone();
|
|
let history = session.history_labels();
|
|
let view = session.view;
|
|
session.begin_stroke_uv(Vec2::splat(0.5), 1.0).unwrap();
|
|
assert!(session.stroke_tiles() > 0, "the stroke must contain paint before the preview starts");
|
|
|
|
if from_settings {
|
|
session.bake_preview_begin_for(&[0]).unwrap();
|
|
} else {
|
|
session.bake_preview_begin(vec![(0, order(&session))]);
|
|
}
|
|
let stroke_survived = session.stroke_active();
|
|
session.continue_stroke_uv(Vec2::splat(0.6), 1.0);
|
|
session.end_stroke().unwrap();
|
|
|
|
assert_eq!(session.history_labels(), history, "releasing the pointer during a preview must not commit paint");
|
|
assert!(!stroke_survived, "activation must cancel the stroke immediately");
|
|
assert_eq!(session.doc.project, before.project);
|
|
assert_eq!(session.doc.pixels.layers, before.pixels.layers);
|
|
assert_eq!(session.doc.pixels.masks, before.pixels.masks);
|
|
assert!(session.bake_preview_active());
|
|
session.bake_preview_end();
|
|
|
|
assert_eq!(session.view, view);
|
|
session.begin_stroke_uv(Vec2::splat(0.5), 1.0).unwrap();
|
|
session.end_stroke().unwrap();
|
|
assert_eq!(session.history_labels().len(), history.len() + 1, "painting resumes after the preview ends");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn a_rejected_bake_preview_preserves_the_active_stroke() {
|
|
let mut session = session();
|
|
execute(&mut session, "layer.add.paint", &Value::Null).unwrap();
|
|
let history_steps = session.history_labels().len();
|
|
let view = session.view;
|
|
session.begin_stroke_uv(Vec2::splat(0.5), 1.0).unwrap();
|
|
let painted_tiles = session.stroke_tiles();
|
|
assert!(painted_tiles > 0);
|
|
|
|
let result = session.bake_preview_begin_for(&[0, session.set_count()]);
|
|
|
|
assert!(result.is_err());
|
|
assert!(!session.bake_preview_active());
|
|
assert!(session.stroke_active());
|
|
assert_eq!(session.stroke_tiles(), painted_tiles);
|
|
assert_eq!(session.view, view);
|
|
session.end_stroke().unwrap();
|
|
|
|
assert_eq!(session.history_labels().len(), history_steps + 1, "a rejected preview must not discard painting");
|
|
}
|