//! Which tools can act on each selection, and that every usable tool acts there in both views mod selection; use selection::Selection; use serde_json::{Value, json}; use texturecraft_engine::core::{Effect, EffectKind, LayerId}; use texturecraft_engine::geom::glam::{Vec2, Vec3}; use texturecraft_engine::{Session, StackTarget, Tool, execute}; /// Two triangles side by side, each a mesh part with its own corner of the UV square const PARTS_OBJ: &str = "o Lid\nv 0 0 0\nv 2 0 0\nv 0 2 0\nvt 0 0\nvt 0.5 0\nvt 0 0.5\nf 1/1 2/2 3/3\n\ o Body\nv 2 2 0\nv 4 2 0\nv 2 4 0\nvt 0.5 0.5\nvt 1 0.5\nvt 0.5 1\nf 4/4 5/5 6/6\n"; const VIEWPORT_PIXELS: f32 = 400.0; fn stencil_png() -> Vec { let mut out = Vec::new(); let green = image::RgbaImage::from_fn(8, 8, |_, _| image::Rgba([0, 255, 0, 255])); green.write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png).unwrap(); out } fn base_session() -> Session { let mut session = Session::from_mesh_bytes("parts.obj", PARTS_OBJ.as_bytes(), 256, "parts").unwrap(); session.viewport = Vec2::splat(VIEWPORT_PIXELS); (session.camera.yaw, session.camera.pitch) = (0.0, 0.0); let (low, high) = session.mesh.bounds(); session.camera.frame(low, high); session.update(); execute(&mut session, "tool.material", &json!({"channel": "baseColor", "color": [1.0, 0.0, 0.0]})).unwrap(); execute(&mut session, "tool.brush", &json!({"size": 6})).unwrap(); let stencil = session.import_resource_bytes("stencil.png", stencil_png()).unwrap(); execute(&mut session, "tool.stencil", &json!({"image": stencil})).unwrap(); session } fn screen(session: &Session, point: [f32; 3]) -> Vec2 { let ndc = session.camera.project(Vec3::from(point), 1.0).unwrap(); Vec2::new((ndc.x + 1.0) * VIEWPORT_PIXELS / 2.0, (1.0 - ndc.y) * VIEWPORT_PIXELS / 2.0) } 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; } /// Adds an effect with `command` to the layer's content or mask and selects it fn select_new_effect(session: &mut Session, layer: u64, mask: bool, command: &str, effect_params: Value) { if mask { execute(session, "mask.add.black", &json!({"layer": layer})).unwrap(); } let target = if mask { "mask" } else { "content" }; let mut params = effect_params; params["layer"] = json!(layer); params["target"] = json!(target); execute(session, command, ¶ms).unwrap(); let owner = session.doc.project.layer(LayerId(layer)).unwrap(); let effects = if mask { &owner.mask.as_ref().unwrap().effects } else { &owner.content_effects }; let effect = effects.last().unwrap().id.0; select(session, layer, json!(effect)); } fn select_new_mask(session: &mut Session, layer: u64) { execute(session, "mask.add.black", &json!({"layer": layer})).unwrap(); select(session, layer, json!("mask")); } fn session_with(selection: Selection) -> Session { let mut session = base_session(); match selection { Selection::PaintContent => { let layer = add_layer(&mut session, "layer.add.paint"); select(&mut session, layer, json!("content")); } Selection::FillContent => { let layer = add_layer(&mut session, "layer.add.fill"); select(&mut session, layer, json!("content")); } Selection::PaintMask => { let layer = add_layer(&mut session, "layer.add.paint"); select_new_mask(&mut session, layer); } Selection::FillMask => { let layer = add_layer(&mut session, "layer.add.fill"); select_new_mask(&mut session, layer); } Selection::FolderMask => { let folder = add_layer(&mut session, "layer.add.group"); select_new_mask(&mut session, folder); } Selection::InstanceOwnMask => { let source = add_layer(&mut session, "layer.add.paint"); let instance = execute(&mut session, "layer.instance", &json!({"layer": source})).unwrap()["layer"].as_u64().unwrap(); select_new_mask(&mut session, instance); } Selection::PaintSublayer => { let layer = add_layer(&mut session, "layer.add.paint"); select_new_effect(&mut session, layer, false, "effect.add.paint", json!({})); } Selection::PaintSublayerInMask => { let layer = add_layer(&mut session, "layer.add.paint"); select_new_effect(&mut session, layer, true, "effect.add.paint", json!({})); } Selection::PaintSublayerInFill => { let layer = add_layer(&mut session, "layer.add.fill"); select_new_effect(&mut session, layer, false, "effect.add.paint", json!({})); } Selection::PathSublayer => { let layer = add_layer(&mut session, "layer.add.paint"); select(&mut session, layer, json!("content")); let (start, end) = (screen(&session, [0.2, 0.2, 0.0]), screen(&session, [1.0, 0.4, 0.0])); execute(&mut session, "tool.path", &json!({"points": [[start.x, start.y], [end.x, end.y]]})).unwrap(); execute(&mut session, "tool.path", &json!({"commit": true})).unwrap(); let path = session.doc.project.layer(LayerId(layer)).unwrap().content_effects.last().unwrap().id.0; select(&mut session, layer, json!(path)); } Selection::FilterInPaint | Selection::FilterInFill | Selection::FilterInMask => { let command = if selection == Selection::FilterInFill { "layer.add.fill" } else { "layer.add.paint" }; let layer = add_layer(&mut session, command); select_new_effect(&mut session, layer, selection == Selection::FilterInMask, "effect.add.filter", json!({"filter": "invert"})); } Selection::FillEffectInPaint => { let layer = add_layer(&mut session, "layer.add.paint"); select_new_effect(&mut session, layer, false, "effect.add.fill", json!({})); } Selection::GeneratorInFillMask => { let layer = add_layer(&mut session, "layer.add.fill"); select_new_effect(&mut session, layer, true, "effect.add.generator", json!({})); } Selection::FolderContent => { let folder = add_layer(&mut session, "layer.add.group"); select(&mut session, folder, json!("content")); } Selection::InstanceOfPaint | Selection::InstanceOfFill => { let command = if selection == Selection::InstanceOfFill { "layer.add.fill" } else { "layer.add.paint" }; let source = add_layer(&mut session, command); let instance = execute(&mut session, "layer.instance", &json!({"layer": source})).unwrap()["layer"].as_u64().unwrap(); select(&mut session, instance, json!("content")); } Selection::Nothing => select_nothing(&mut session), Selection::QuickMaskOverPaint | Selection::QuickMaskOverFill => { let command = if selection == Selection::QuickMaskOverFill { "layer.add.fill" } else { "layer.add.paint" }; let layer = add_layer(&mut session, command); select(&mut session, layer, json!("content")); execute(&mut session, "viewport.quickMask", &json!({"enabled": true})).unwrap(); execute(&mut session, "viewport.quickMask.edit", &json!({"editing": true})).unwrap(); } Selection::QuickMaskOverNothing => { select_nothing(&mut session); execute(&mut session, "viewport.quickMask", &json!({"enabled": true})).unwrap(); execute(&mut session, "viewport.quickMask.edit", &json!({"editing": true})).unwrap(); } } session } /// Uses `tool` once the way the viewport does: a stroke, a click or a committed path fn use_tool(session: &mut Session, tool: Tool, in_2d_view: bool) -> texturecraft_engine::Result<()> { session.tool.tool = tool; if tool == Tool::Clone { let source = screen(session, [1.2, 0.3, 0.0]); execute(session, "tool.cloneSource", &json!({"x": source.x, "y": source.y}))?; } let points = [screen(session, [0.3, 0.3, 0.0]), screen(session, [0.6, 0.4, 0.0]), screen(session, [0.9, 0.5, 0.0])]; let uv_points = [Vec2::new(0.05, 0.95), Vec2::new(0.1, 0.92), Vec2::new(0.15, 0.9)]; if tool == Tool::Path { let params = if in_2d_view { json!({"uvPoints": uv_points.iter().map(|uv| [uv.x, uv.y]).collect::>()}) } else { json!({"points": points.iter().map(|point| [point.x, point.y]).collect::>()}) }; execute(session, "tool.path", ¶ms)?; execute(session, "tool.path", &json!({"commit": true}))?; return Ok(()); } let single_click = matches!(tool, Tool::PolygonFill | Tool::ColorPicker | Tool::GeometryMask); let viewport = session.viewport; if in_2d_view { session.begin_stroke_uv(uv_points[0], 1.0)?; } else { session.begin_stroke(points[0], viewport, 1.0)?; } if single_click { return Ok(()); } for (point, uv) in points.iter().zip(&uv_points).skip(1) { if in_2d_view { session.continue_stroke_uv(*uv, 1.0); } else { session.continue_stroke(*point, 1.0); } } session.end_stroke() } #[test] fn every_selection_offers_the_tools_that_can_act_on_it() { let mut wrong = Vec::new(); for selection in Selection::ALL { let session = session_with(selection); for tool in Tool::ALL { let usable = session.tool_usable(tool); if usable != selection.offers(tool) { wrong.push(format!("{selection:?} {tool:?}: usable {usable}")); } } } assert!(wrong.is_empty(), "{wrong:#?}"); } #[test] fn every_usable_tool_acts_in_both_views() { let mut wrong = Vec::new(); for in_2d_view in [false, true] { for selection in Selection::ALL { for tool in Tool::ALL { // The picker and the geometry mask read the 3D view only, whatever is selected if in_2d_view && matches!(tool, Tool::ColorPicker | Tool::GeometryMask) { continue; } let mut session = session_with(selection); let usable = session.tool_usable(tool); let result = use_tool(&mut session, tool, in_2d_view); let view = if in_2d_view { "2D" } else { "3D" }; match result { Err(error) if usable => wrong.push(format!("{view} {selection:?} {tool:?}: usable but {error}")), Ok(()) if !usable && !selection.scripts_still_paint() => wrong.push(format!("{view} {selection:?} {tool:?}: greyed but acts")), _ => {} } } } } assert!(wrong.is_empty(), "{wrong:#?}"); } fn commit_path(session: &mut Session) -> texturecraft_engine::Result { execute(session, "tool.path", &json!({"uvPoints": [[0.05, 0.95], [0.15, 0.9]], "commit": true})) } fn path_count(session: &Session, path_sublayer: LayerId) -> usize { match session.doc.project.effect(path_sublayer).map(|(_, effect)| &effect.kind) { Some(EffectKind::Path(paths)) => paths.len(), _ => 0, } } #[test] fn paths_are_refused_on_fill_layers_and_the_quick_mask_but_saved_ones_stay_editable() { let mut session = session_with(Selection::FillContent); let fill = session.selected_layer().unwrap(); assert!(commit_path(&mut session).is_err(), "no new paths in a fill layer"); assert!(session.doc.project.layer(fill).unwrap().content_effects.is_empty()); let mut session = session_with(Selection::QuickMaskOverPaint); assert!(commit_path(&mut session).is_err(), "paths can't edit the quick mask"); // A project saved while paths could go into fill layers let mut session = session_with(Selection::FillContent); let fill = session.selected_layer().unwrap(); let saved_path = session.doc.project.alloc_id(); session.doc.project.layer_mut(fill).unwrap().content_effects.push(Effect::new(saved_path, EffectKind::Path(Vec::new()))); select(&mut session, fill.0, json!(saved_path.0)); assert!(session.tool_usable(Tool::Path)); commit_path(&mut session).unwrap(); assert_eq!(path_count(&session, saved_path), 1, "the saved path sublayer takes the new path"); } #[test] fn quick_mask_edit_and_invert_need_the_mask_on() { let mut session = base_session(); assert!(execute(&mut session, "viewport.quickMask.edit", &json!({"editing": true})).is_err()); assert!(execute(&mut session, "viewport.quickMask.invert", &json!({})).is_err()); execute(&mut session, "viewport.quickMask", &json!({"enabled": true})).unwrap(); execute(&mut session, "viewport.quickMask.edit", &json!({"editing": true})).unwrap(); execute(&mut session, "viewport.quickMask", &json!({"enabled": false})).unwrap(); assert!(!session.quick_mask.editing, "turning the mask off stops editing it"); } #[test] fn a_saved_path_cannot_be_committed_while_editing_the_quick_mask() { let mut session = session_with(Selection::PaintContent); commit_path(&mut session).unwrap(); let StackTarget::Effect(path_sublayer) = session.target else { panic!("the committed path is not selected") }; let points_before = match session.doc.project.effect(path_sublayer).map(|(_, effect)| &effect.kind) { Some(EffectKind::Path(paths)) => paths[0].points.clone(), _ => panic!("the committed path is missing"), }; execute(&mut session, "viewport.quickMask", &json!({"enabled": true})).unwrap(); execute(&mut session, "viewport.quickMask.edit", &json!({"editing": true})).unwrap(); execute(&mut session, "path.edit", &json!({"effect": path_sublayer.0, "index": 0})).unwrap(); assert!(!session.tool_usable(Tool::Path)); execute(&mut session, "tool.path", &json!({"uvPoints": [[0.2, 0.8], [0.3, 0.7]]})).unwrap(); assert!(!session.path_live().unwrap(), "live preview must leave the stored path alone"); let result = execute(&mut session, "tool.path", &json!({"commit": true})); assert!(result.is_err(), "a greyed Path tool must not commit a stored path into the quick mask edit state"); let points_after = match session.doc.project.effect(path_sublayer).map(|(_, effect)| &effect.kind) { Some(EffectKind::Path(paths)) => paths[0].points.clone(), _ => panic!("the stored path is missing"), }; assert_eq!(points_after, points_before); }