d84914ef1e5a
tool_availability.rs
//! The shelf greys tools that can't act on the selection; the top bar and Properties follow it
use egui_kittest::Harness;
use egui_kittest::kittest::{NodeT, Queryable};
use serde_json::{Value, json};
use texturecraft_engine::{Session, StackTarget, Tool, execute};
use texturecraft_ui_egui::TextureCraftApp;
use texturecraft_ui_egui::state::Mode;
use texturecraft_ui_egui::theme::Brightness;
fn add_layer(session: &mut Session, command: &str) -> u64 {
execute(session, command, &json!({})).unwrap()["layer"].as_u64().unwrap()
}
fn select(session: &mut Session, layer: u64, target: Value) {
execute(session, "layer.select", &json!({"layer": layer, "target": target})).unwrap();
}
fn select_nothing(session: &mut Session) {
let set = session.ts();
session.selected.remove(&set);
session.target = StackTarget::Content;
}
fn app_harness() -> Harness<'static, TextureCraftApp> {
let session = texturecraft_engine::sample_session(256, 64).unwrap();
let mut harness = Harness::builder().with_size(egui::vec2(1600.0, 960.0)).build_eframe(|context| TextureCraftApp::new(context, session));
harness.run_steps(4);
harness
}
/// Selects a new fill layer's content with `tool` equipped
fn select_fill_content(harness: &mut Harness<'_, TextureCraftApp>, tool: Tool) {
let session = &mut harness.state_mut().session;
let fill = add_layer(session, "layer.add.fill");
select(session, fill, json!("content"));
session.tool.tool = tool;
harness.run_steps(4);
}
fn shelf_button_disabled(harness: &Harness<'_, TextureCraftApp>, label: &str) -> bool {
harness.get_by_label(label).accesskit_node().is_disabled()
}
fn shelf_button_selected(harness: &Harness<'_, TextureCraftApp>, label: &str) -> bool {
harness.get_by_label(label).accesskit_node().toggled() == Some(egui::accesskit::Toggled::True)
}
fn shows_text(harness: &Harness<'_, TextureCraftApp>, text: &str) -> bool {
harness.output().shapes.iter().any(|shape| matches!(&shape.shape, egui::Shape::Text(found) if found.galley.text() == text))
}
#[test]
fn a_fill_layer_greys_the_paint_tools_and_shows_its_own_properties() {
let mut harness = app_harness();
let session = &mut harness.state_mut().session;
let paint = add_layer(session, "layer.add.paint");
select(session, paint, json!("content"));
harness.run_steps(4);
assert!(!shelf_button_disabled(&harness, "Paint (1)"));
assert!(shelf_button_selected(&harness, "Paint (1)"));
assert!(shows_text(&harness, "Size"), "the brush controls are in the top bar");
select_fill_content(&mut harness, Tool::PolygonFill);
assert!(shelf_button_disabled(&harness, "Paint (1)"));
assert!(shelf_button_disabled(&harness, "Polygon fill (4)"));
assert!(!shelf_button_selected(&harness, "Polygon fill (4)"), "the equipped tool doesn't show as selected while greyed");
assert!(!shelf_button_disabled(&harness, "Geometry mask (8)"));
assert!(shows_text(&harness, "Properties - Fill"), "a fill layer shows its fill whatever the tool");
assert!(!shows_text(&harness, "Size"), "a tool that can't act leaves the top bar");
}
#[test]
fn shortcuts_skip_the_tools_the_shelf_greys() {
let mut harness = app_harness();
select_fill_content(&mut harness, Tool::Paint);
harness.key_press(egui::Key::Num2);
harness.run_steps(2);
assert_eq!(harness.state().session.tool.tool, Tool::Paint, "Eraser can't act on a fill layer");
harness.key_press(egui::Key::P);
harness.run_steps(2);
assert_eq!(harness.state().session.tool.tool, Tool::ColorPicker);
}
/// Drag with the left button across the middle of the 3D view, as a stroke would
fn drag_across_the_view(harness: &mut Harness<'_, TextureCraftApp>) {
const STEPS: usize = 4;
const STEP_POINTS: f32 = 15.0;
let center = harness.state().viewport_rect.center();
let modifiers = egui::Modifiers::NONE;
harness.hover_at(center);
harness.event(egui::Event::PointerButton { pos: center, button: egui::PointerButton::Primary, pressed: true, modifiers });
harness.run_steps(2);
for step in 1..=STEPS {
harness.hover_at(center + egui::vec2(STEP_POINTS * step as f32, 0.0));
harness.run_steps(1);
}
let end = center + egui::vec2(STEP_POINTS * STEPS as f32, 0.0);
harness.event(egui::Event::PointerButton { pos: end, button: egui::PointerButton::Primary, pressed: false, modifiers });
harness.run_steps(3);
}
#[test]
fn a_tool_that_cant_act_ignores_the_view() {
let mut harness = app_harness();
let session = &mut harness.state_mut().session;
let paint = add_layer(session, "layer.add.paint");
select(session, paint, json!("content"));
harness.run_steps(4);
let steps_before = harness.state().session.history_labels().len();
drag_across_the_view(&mut harness);
assert!(harness.state().session.history_labels().len() > steps_before, "the drag reaches the mesh and paints a paint layer");
for tool in [Tool::Paint, Tool::PolygonFill, Tool::Path] {
select_fill_content(&mut harness, tool);
let steps_before = harness.state().session.history_labels().len();
drag_across_the_view(&mut harness);
let state = harness.state();
assert!(state.toasts.is_empty(), "{tool:?} on a fill layer: no error toast, got {:?}", state.toasts.first().map(|toast| &toast.text));
assert_eq!(state.session.history_labels().len(), steps_before, "{tool:?} on a fill layer changes nothing");
assert!(state.session.tool.path.points.is_empty(), "{tool:?} places no path points");
}
}
#[test]
fn bake_painting_turns_on_the_shelf_paint_tool() {
let mut session = texturecraft_engine::sample_session(256, 64).unwrap();
session.add_high_poly_bytes("High.obj", b"v 0 0 0\nv 1 0 0\nv 0 1 0\nf 1 2 3\n".to_vec()).unwrap();
let mut harness = Harness::builder().with_size(egui::vec2(1600.0, 960.0)).build_eframe(|context| TextureCraftApp::new(context, session));
harness.state_mut().ui.mode = Mode::Baking;
harness.run_steps(4);
assert!(shelf_button_disabled(&harness, "Paint (1)"), "nothing is being painted yet");
harness.state_mut().ui.bake_paint_brush.on = true;
harness.run_steps(4);
assert!(harness.state().ui.bake_paint_brush.on, "the high poly allows bake painting");
assert!(!shelf_button_disabled(&harness, "Paint (1)"), "Paint is the bake brush while it paints");
assert!(shelf_button_disabled(&harness, "Eraser (2)"));
assert!(shelf_button_disabled(&harness, "Polygon fill (4)"));
}
#[test]
fn nothing_selected_asks_for_a_layer() {
let mut harness = app_harness();
select_nothing(&mut harness.state_mut().session);
harness.run_steps(4);
assert!(shows_text(&harness, "Select a layer to paint on"));
assert!(shelf_button_disabled(&harness, "Geometry mask (8)"));
}
#[test]
fn baking_keeps_three_greyed_tools_and_rendering_none() {
let mut harness = app_harness();
harness.state_mut().ui.mode = Mode::Baking;
harness.run_steps(4);
for label in ["Paint (1)", "Eraser (2)", "Polygon fill (4)"] {
assert!(shelf_button_disabled(&harness, label), "{label}");
}
assert!(harness.query_by_label("Path (7)").is_none());
harness.state_mut().ui.mode = Mode::Rendering;
harness.run_steps(4);
assert!(harness.query_by_label("Paint (1)").is_none());
}
#[test]
#[ignore = "offscreen GPU snapshots; set TC_UI_SNAPSHOTS to an output directory"]
fn tool_availability_snapshots() {
let Some(directory) = std::env::var_os("TC_UI_SNAPSHOTS").map(std::path::PathBuf::from) else {
return;
};
std::fs::create_dir_all(&directory).unwrap();
let session = texturecraft_engine::sample_session(256, 64).unwrap();
let mut harness = Harness::builder().with_size(egui::vec2(1600.0, 960.0)).wgpu().build_eframe(|context| TextureCraftApp::new(context, session));
let save = |harness: &mut Harness<'_, TextureCraftApp>, name: &str| {
for (brightness, suffix) in [(Brightness::MediumDark, "medium"), (Brightness::Dark, "dark"), (Brightness::Light, "light")] {
harness.state_mut().ui.prefs.brightness = brightness;
harness.run_steps(8);
harness.render().unwrap().save(directory.join(format!("{name}-{suffix}.png"))).unwrap();
}
};
let session = &mut harness.state_mut().session;
let paint = add_layer(session, "layer.add.paint");
select(session, paint, json!("content"));
session.tool.tool = Tool::Paint;
save(&mut harness, "paint-layer");
let session = &mut harness.state_mut().session;
let fill = add_layer(session, "layer.add.fill");
select(session, fill, json!("content"));
session.tool.tool = Tool::PolygonFill;
save(&mut harness, "fill-content-polygon-fill");
let session = &mut harness.state_mut().session;
execute(session, "effect.add.filter", &json!({"layer": paint, "target": "content", "filter": "blur"})).unwrap();
let filter = session.doc.project.layer(texturecraft_engine::core::LayerId(paint)).unwrap().content_effects.last().unwrap().id.0;
select(session, paint, json!(filter));
session.tool.tool = Tool::Paint;
save(&mut harness, "filter");
let session = &mut harness.state_mut().session;
execute(session, "mask.add.black", &json!({"layer": paint})).unwrap();
select(session, paint, json!("mask"));
session.tool.tool = Tool::Smudge;
save(&mut harness, "mask-smudge");
let session = &mut harness.state_mut().session;
let folder = add_layer(session, "layer.add.group");
select(session, folder, json!("content"));
session.tool.tool = Tool::Paint;
save(&mut harness, "folder");
select_nothing(&mut harness.state_mut().session);
save(&mut harness, "nothing-selected");
harness.state_mut().ui.mode = Mode::Baking;
save(&mut harness, "baking");
harness.state_mut().ui.mode = Mode::Rendering;
save(&mut harness, "rendering");
}
#[test]
fn unavailable_effect_tools_hide_their_properties() {
for path in [false, true] {
let mut harness = app_harness();
let session = &mut harness.state_mut().session;
let mut layer = add_layer(session, "layer.add.paint");
select(session, layer, json!("content"));
let (effect, usable, blocked) = if path {
let result = execute(session, "tool.path", &json!({"uvPoints": [[0.2, 0.5], [0.8, 0.5]], "commit": true})).unwrap();
(result["committed"]["effect"].as_u64().unwrap(), Tool::Path, Tool::Paint)
} else {
// A paint sublayer in a fill layer takes brushes, but no paths
let fill = add_layer(session, "layer.add.fill");
let result = execute(session, "effect.add.paint", &json!({"layer": fill, "target": "content"})).unwrap();
layer = fill;
(result["effect"].as_u64().unwrap(), Tool::Paint, Tool::Path)
};
select(session, layer, json!(effect));
session.tool.tool = usable;
harness.run_steps(4);
assert!(shows_text(&harness, "Size"));
harness.state_mut().session.tool.tool = blocked;
harness.run_steps(4);
assert!(!shows_text(&harness, "Size"), "unavailable effect tools hide brush controls");
if let Some(directory) = std::env::var_os("TC_UI_SNAPSHOTS") {
let directory = std::path::PathBuf::from(directory);
std::fs::create_dir_all(&directory).unwrap();
let name = if path { "unavailable-path-effect.png" } else { "unavailable-fill-paint-effect.png" };
harness.render().unwrap().save(directory.join(name)).unwrap();
}
}
}
#[test]
fn clone_and_smudge_are_offered_for_a_layer_mask() {
let mut harness = app_harness();
let session = &mut harness.state_mut().session;
let paint = add_layer(session, "layer.add.paint");
execute(session, "mask.add.black", &json!({"layer": paint})).unwrap();
select(session, paint, json!("mask"));
session.tool.tool = Tool::Smudge;
harness.run_steps(4);
assert!(!shelf_button_disabled(&harness, "Smudge (5)"));
assert!(!shelf_button_disabled(&harness, "Clone (6)"));
assert!(shelf_button_selected(&harness, "Smudge (5)"));
assert!(shows_text(&harness, "Size"), "the brush controls stay in the top bar");
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.