Files
chasse20 7a780244d9 Auto: Integrate main and guard unavailable tool actions
Preserve the shared-catalog integration and saved review repairs. Reject saved path commits during quick-mask editing, hide the unavailable 2D brush cursor, and reduce dirty-tile selection work. Keep the Selection test fixture in its own module.
2026-11-15 20:47:26 +00:00

337 lines
15 KiB
Rust

//! 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<u8> {
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, &params).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::<Vec<_>>()})
} else {
json!({"points": points.iter().map(|point| [point.x, point.y]).collect::<Vec<_>>()})
};
execute(session, "tool.path", &params)?;
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<Value> {
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);
}