Add Edit > Change mesh... to move a project onto another mesh

crates/engine/src/file_cmds.rs

@@ -37,6 +37,15 @@ pub fn specs() -> Vec<CommandSpec> {
             always,
             reimport
         ),
+        cmd!(
+            "file.changeMesh",
+            "Change mesh...",
+            ["Edit"],
+            None,
+            "{path: the new mesh file, preserveStrokes?: bool (painted pixels follow the surface where the UVs differ; default true)} → {preserved?: texels re-projected}. Keeps layers, texture sets and settings; texture sets map to the new mesh by material index",
+            always,
+            change_mesh
+        ),
         cmd!(
             "file.exportTextures",
             "Export textures",
@@ -438,6 +447,13 @@ fn reimport(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(reply)
 }
 
+#[cfg(not(target_arch = "wasm32"))]
+fn change_mesh(s: &mut Session, p: &Value) -> Result<Value> {
+    let path = native::path_param(p, "path", "file.changeMesh")?;
+    let file = native::read_mesh("file.changeMesh", path)?;
+    s.reimport_mesh(Some(file), crate::commands::boolp(p, "preserveStrokes").unwrap_or(true))
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 impl Session {
     /// The file the mesh was imported from, when it is still there: what Reimport mesh reads again.
@@ -471,6 +487,19 @@ impl Session {
         let mut next = Session::new(doc, mesh, source)?;
         next.log.extend(warnings);
         next.path = self.path.clone();
+        next.sync_images();
+        // The high polys and the skew map stay. The cage is sampled by triangle index and
+        // barycentrics, so it stays only for an identical mesh; the low poly's base colours are
+        // read again from the new mesh.
+        next.bake_meshes = self.bake_meshes.clone();
+        next.bake_meshes.low_base_color = Default::default();
+        if next.bake_meshes.cage.is_some() && *next.mesh != *self.mesh {
+            next.bake_meshes.cage = None;
+            next.log.push("the cage mesh was dropped: the low-poly mesh changed".into());
+        }
+        if self.doc.bake_paint.keys().any(|(_, target)| *target == texturecraft_core::BakePaintTarget::Skew) && self.source.uvs != next.source.uvs {
+            next.log.push("the skew map is laid over the old UV layout; check it in Bake mode".into());
+        }
         next.modified = true;
         next.project_id = self.project_id;
         let preserved = preserve_strokes.then(|| crate::preserve::preserve_strokes(self, &mut next));
@@ -621,6 +650,8 @@ use unsupported as save_copy;
 #[cfg(target_arch = "wasm32")]
 use unsupported as reimport;
 #[cfg(target_arch = "wasm32")]
+use unsupported as change_mesh;
+#[cfg(target_arch = "wasm32")]
 use unsupported as export_textures;
 #[cfg(target_arch = "wasm32")]
 use unsupported as export_mesh;
@@ -764,6 +795,49 @@ f 1/1 2/2 3/3
         let _ = std::fs::remove_dir_all(&dir);
     }
 
+    /// A project built on one mesh moves to another mesh file with its layers intact, even when
+    /// it carries its own copy of the mesh (a plain reimport would only re-read that copy).
+    #[test]
+    fn change_mesh_swaps_the_mesh_and_keeps_the_layers() {
+        let dir = std::env::temp_dir().join(format!("tc_change_mesh_{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let quad = dir.join("quad.obj");
+        std::fs::write(&quad, "v 0 0 0\nv 1 0 0\nv 1 1 0\nv 0 1 0\nvt 0 0\nvt 1 0\nvt 1 1\nvt 0 1\nf 1/1 2/2 3/3 4/4\n").unwrap();
+        let tri = dir.join("tri.obj");
+        std::fs::write(&tri, "v 0 0 0\nv 1 0 0\nv 0 1 0\nvt 0 0\nvt 1 0\nvt 0 1\nf 1/1 2/2 3/3\n").unwrap();
+        let mut s = Session::from_mesh_bytes("quad.obj", &std::fs::read(&quad).unwrap(), 128, "quad").unwrap();
+        crate::execute(&mut s, "layer.add.fill", &json!({"color": [1.0, 0.0, 0.0]})).unwrap();
+        let layers = s.doc.project.layers.len();
+        assert!(crate::execute(&mut s, "file.changeMesh", &json!({})).is_err(), "a path is required");
+        crate::execute(&mut s, "file.changeMesh", &json!({"path": tri.display().to_string()})).unwrap();
+        assert_eq!(s.mesh.triangle_count(), 1, "the new mesh is in use");
+        assert_eq!(s.doc.project.mesh_file, "tri.obj");
+        assert_eq!(s.doc.project.layers.len(), layers, "the layers stay");
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    #[test]
+    fn change_mesh_resets_base_colours_and_drops_a_cage_of_another_mesh() {
+        let dir = std::env::temp_dir().join(format!("tc_change_mesh_cage_{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let a = dir.join("a.obj");
+        std::fs::write(&a, "v 0 0 0\nv 1 0 0\nv 0 1 0\nvt 0 0\nvt 1 0\nvt 0 1\nf 1/1 2/2 3/3\n").unwrap();
+        // Same triangle count, other vertices.
+        let b = dir.join("b.obj");
+        std::fs::write(&b, "v 0 0 0\nv 2 0 0\nv 0 2 0\nvt 0 0\nvt 1 0\nvt 0 1\nf 1/1 2/2 3/3\n").unwrap();
+        let mut s = Session::from_mesh_bytes("a.obj", &std::fs::read(&a).unwrap(), 128, "a").unwrap();
+        let cage = crate::bake::BakeMesh { name: "cage".into(), bytes: Default::default(), mesh: s.mesh.clone(), base_color: Vec::new() };
+        s.bake_meshes.cage = Some(cage);
+        let _ = s.bake_meshes.low_base_color.set(Err("old".into()));
+        // The same mesh again keeps the cage but not the cached colours.
+        crate::execute(&mut s, "file.changeMesh", &json!({"path": a.display().to_string()})).unwrap();
+        assert!(s.bake_meshes.cage.is_some());
+        assert!(s.bake_meshes.low_base_color.get().is_none(), "the colours are read again");
+        crate::execute(&mut s, "file.changeMesh", &json!({"path": b.display().to_string()})).unwrap();
+        assert!(s.bake_meshes.cage.is_none(), "the cage was made for another mesh");
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
     #[test]
     fn unnamed_parts_keep_their_names_and_masks_through_save_and_reopen() {
         // A GLB quad whose mesh and node have no name: its one part is named after the file.

crates/engine/src/preserve.rs

@@ -16,8 +16,14 @@ use crate::Session;
 const REACH: f32 = 0.05;
 
 /// Re-project the painted pixels of `next` (a session on the reimported mesh holding `old`'s
-/// document) from `old`'s UV layout. Returns how many texels found the old surface.
+/// document) from `old`'s UV layout. Returns how many texels found the old surface;
+/// a texture set where none does keeps its pixels as they are. Nothing is re-projected when the
+/// UV layout and topology are unchanged (same triangles, materials and UVs): the pixels already
+/// sit where they belong, however far the mesh moved.
 pub(crate) fn preserve_strokes(old: &Session, next: &mut Session) -> usize {
+    if same_layout(&old.mesh, &next.mesh) {
+        return 0;
+    }
     let reach = REACH * 2.0 * old.mesh.radius().max(next.mesh.radius());
     let mut found = 0;
     for ts in 0..next.set_count() {
@@ -52,7 +58,12 @@ pub(crate) fn preserve_strokes(old: &Session, next: &mut Session) -> usize {
                 ((tx, ty), src)
             })
             .collect();
-        found += table.values().flatten().filter(|p| p[0].is_finite()).count();
+        let matched = table.values().flatten().filter(|p| p[0].is_finite()).count();
+        found += matched;
+        // No old surface within reach anywhere (a moved or unrelated mesh): the paint stays where it is.
+        if matched == 0 {
+            continue;
+        }
         let map = |x: f32, y: f32| {
             let (xi, yi) = (x as u32, y as u32);
             table.get(&(xi / TILE, yi / TILE)).and_then(|t| t.get(((yi % TILE) * TILE + xi % TILE) as usize)).filter(|p| p[0].is_finite()).map(|p| (p[0], p[1]))
@@ -63,6 +74,12 @@ pub(crate) fn preserve_strokes(old: &Session, next: &mut Session) -> usize {
     found
 }
 
+/// Same index buffer, same UVs per vertex and the same material ranges.
+fn same_layout(a: &texturecraft_geom::Mesh, b: &texturecraft_geom::Mesh) -> bool {
+    let ranges = |m: &texturecraft_geom::Mesh| m.submeshes.iter().map(|s| (s.material, s.start, s.count)).collect::<Vec<_>>();
+    a.indices == b.indices && a.uvs == b.uvs && ranges(a) == ranges(b)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -104,4 +121,50 @@ mod tests {
         }
         assert!(right > 10_000 && wrong == 0, "{right} right, {wrong} wrong");
     }
+
+    #[test]
+    fn a_mesh_with_no_surface_in_reach_keeps_the_paint_where_it_is() {
+        let mut s = Session::new_project("p", primitives::builtin("plane").unwrap(), "builtin:plane", None, 128).unwrap();
+        let id = s.doc.project.texture_sets[0].stack[0];
+        let img = s.doc.pixels.layer_mut(id, Channel::BaseColor, (128, 128));
+        for x in 0..64 {
+            img.set(x, 40, &[65535, 0, 0, 65535]);
+        }
+        // The same plane far away and with mirrored UVs (so the layout differs and the unchanged-layout
+        // shortcut is not taken): nothing of the old surface is within reach.
+        let mut mesh = (*s.mesh).clone();
+        for p in &mut mesh.positions {
+            p.x += 100.0;
+        }
+        for uv in &mut mesh.uvs {
+            *uv = Vec2::new(1.0 - uv.x, uv.y);
+        }
+        let mut next = Session::new(s.doc.clone(), mesh, None).unwrap();
+        assert_eq!(preserve_strokes(&s, &mut next), 0);
+        let img = next.doc.pixels.layer(id, Channel::BaseColor).unwrap();
+        assert_eq!(img.get(10, 40)[3], 65535, "the painted texel is still there");
+    }
+
+    #[test]
+    fn a_translated_mesh_with_the_same_uvs_keeps_every_pixel() {
+        let mut s = Session::new_project("p", primitives::builtin("plane").unwrap(), "builtin:plane", None, 128).unwrap();
+        let id = s.doc.project.texture_sets[0].stack[0];
+        let img = s.doc.pixels.layer_mut(id, Channel::BaseColor, (128, 128));
+        for x in 0..128 {
+            img.set(x, 40, &[65535, 0, 0, 65535]);
+        }
+        // Slid along its own surface by a fraction of the plane: half of it still overlaps the old one.
+        let mut mesh = (*s.mesh).clone();
+        let shift = mesh.radius() * 0.5;
+        for p in &mut mesh.positions {
+            p.x += shift;
+        }
+        let mut next = Session::new(s.doc.clone(), mesh, None).unwrap();
+        assert_eq!(preserve_strokes(&s, &mut next), 0);
+        let img = next.doc.pixels.layer(id, Channel::BaseColor).unwrap();
+        for x in 0..128 {
+            assert_eq!(img.get(x, 40)[3], 65535, "texel {x} of the painted row moved");
+            assert_eq!(img.get(x, 41)[3], 0, "texel {x} of the next row got paint");
+        }
+    }
 }

crates/engine/tests/it/bake.rs

@@ -612,3 +612,42 @@ fn a_failed_multi_set_bake_restores_settings_pixels_and_history() {
     assert_eq!(session.doc.baked, original.baked);
     assert_eq!(session.history_labels(), history);
 }
+
+/// Edit > Change mesh swaps the mesh under a baked project: the high poly and the skew map stay,
+/// the project counts as changed, and image resources are decoded in the new session.
+#[test]
+fn changing_the_mesh_keeps_the_bake_setup_and_marks_the_project_changed() {
+    let mut s = plane_session();
+    let plane = s.mesh.as_ref().clone();
+    let high = temp_file("change_high.obj", &obj(&plane, 0.002, f32::MAX, [1.0; 3]));
+    execute(&mut s, "bake.highPoly.add", &json!({ "path": high })).unwrap();
+    execute(&mut s, "bake.skew.set", &json!({ "value": 1.0 })).unwrap();
+    // 1x1 PNG as an image resource.
+    let png = [
+        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08,
+        0x06, 0x00, 0x00, 0x00, 0x1f, 0x15, 0xc4, 0x89, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9c, 0x63, 0xf8, 0xcf, 0xc0, 0xf0, 0x1f, 0x00,
+        0x05, 0x00, 0x01, 0xff, 0x89, 0x99, 0x3d, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
+    ];
+    s.import_resource_bytes("dot.png", png.to_vec()).unwrap();
+    s.modified = false;
+    let mesh_id = s.mesh_id;
+
+    let mut low = String::new();
+    for p in &plane.positions {
+        low += &format!("v {} {} {}\n", p.x, p.y, p.z);
+    }
+    for uv in &plane.uvs {
+        low += &format!("vt {} {}\n", uv.x, 1.0 - uv.y);
+    }
+    for t in plane.indices.as_chunks::<3>().0 {
+        low += &format!("f {a}/{a} {b}/{b} {c}/{c}\n", a = t[0] + 1, b = t[1] + 1, c = t[2] + 1);
+    }
+    let low = temp_file("change_low.obj", &low);
+    execute(&mut s, "file.changeMesh", &json!({ "path": low })).unwrap();
+
+    assert_ne!(s.mesh_id, mesh_id, "the session is on a new mesh");
+    assert_eq!(s.bake_meshes.high.len(), 1, "the high poly stays");
+    assert!(s.doc.bake_paint.keys().any(|(_, target)| *target == texturecraft_engine::core::BakePaintTarget::Skew), "the skew map stays");
+    assert!(s.modified, "the project differs from the saved one");
+    assert_eq!(s.images.len(), 1, "image resources are decoded in the new session");
+}

crates/ui-egui/src/bake_job.rs

@@ -5,4 +5,6 @@ pub struct BakeJob {
     pub queue: Vec<usize>,
     pub current: Option<RunningBake>,
     pub total: usize,
+    /// The mesh the job was started on: a result for another mesh (changed or reimported meanwhile) is not applied.
+    pub mesh_id: u64,
 }

crates/ui-egui/src/i18n/ar.rs

@@ -636,6 +636,8 @@ pub const TABLE: &[(&str, &str)] = &[
     ),
     ("Redo", "إعادة"),
     ("Reimport mesh", "إعادة استيراد المجسم"),
+    ("Change mesh...", "تغيير المجسم..."),
+    ("Relative to the bounding box diagonal.", "نسبة إلى قطر المربع المحيط."),
     ("Remove", "إزالة"),
     ("Remove channel", "إزالة القناة"),
     ("Remove effect", "إزالة التأثير"),

crates/ui-egui/src/i18n/de.rs

@@ -675,6 +675,8 @@ pub const TABLE: &[(&str, &str)] = &[
     ),
     ("Redo", "Wiederholen"),
     ("Reimport mesh", "Mesh neu importieren"),
+    ("Change mesh...", "Mesh ändern..."),
+    ("Relative to the bounding box diagonal.", "Relativ zur Diagonale des Begrenzungsrahmens."),
     ("Remove", "Entfernen"),
     ("Remove channel", "Kanal entfernen"),
     ("Remove effect", "Effekt entfernen"),

crates/ui-egui/src/i18n/es.rs

@@ -663,6 +663,8 @@ pub const TABLE: &[(&str, &str)] = &[
     ),
     ("Redo", "Rehacer"),
     ("Reimport mesh", "Reimportar malla"),
+    ("Change mesh...", "Cambiar malla..."),
+    ("Relative to the bounding box diagonal.", "Relativo a la diagonal del cuadro delimitador."),
     ("Remove", "Quitar"),
     ("Remove channel", "Quitar canal"),
     ("Remove effect", "Quitar efecto"),

crates/ui-egui/src/i18n/fr.rs

@@ -678,6 +678,8 @@ pub const TABLE: &[(&str, &str)] = &[
     ),
     ("Redo", "Rétablir"),
     ("Reimport mesh", "Réimporter le maillage"),
+    ("Change mesh...", "Changer le maillage..."),
+    ("Relative to the bounding box diagonal.", "Relatif à la diagonale de la boîte englobante."),
     ("Remove", "Supprimer"),
     ("Remove channel", "Supprimer le canal"),
     ("Remove effect", "Supprimer l'effet"),

crates/ui-egui/src/i18n/it.rs

@@ -672,6 +672,8 @@ pub const TABLE: &[(&str, &str)] = &[
     ),
     ("Redo", "Ripeti"),
     ("Reimport mesh", "Reimporta mesh"),
+    ("Change mesh...", "Cambia mesh..."),
+    ("Relative to the bounding box diagonal.", "Relativa alla diagonale del bounding box."),
     ("Remove", "Rimuovi"),
     ("Remove channel", "Rimuovi canale"),
     ("Remove effect", "Rimuovi effetto"),

crates/ui-egui/src/i18n/ja.rs

@@ -654,6 +654,8 @@ pub const TABLE: &[(&str, &str)] = &[
     ),
     ("Redo", "やり直し"),
     ("Reimport mesh", "メッシュを再インポート"),
+    ("Change mesh...", "メッシュを変更..."),
+    ("Relative to the bounding box diagonal.", "バウンディングボックスの対角線に対する相対値。"),
     ("Remove", "削除"),
     ("Remove channel", "チャンネルを削除"),
     ("Remove effect", "エフェクトを削除"),

crates/ui-egui/src/i18n/ko.rs

@@ -645,6 +645,8 @@ pub const TABLE: &[(&str, &str)] = &[
     ),
     ("Redo", "다시 실행"),
     ("Reimport mesh", "메시 다시 가져오기"),
+    ("Change mesh...", "메시 변경..."),
+    ("Relative to the bounding box diagonal.", "바운딩 박스 대각선 기준입니다."),
     ("Remove", "제거"),
     ("Remove channel", "채널 제거"),
     ("Remove effect", "이펙트 제거"),

crates/ui-egui/src/i18n/pt_br.rs

@@ -660,6 +660,8 @@ pub const TABLE: &[(&str, &str)] = &[
     ),
     ("Redo", "Refazer"),
     ("Reimport mesh", "Reimportar malha"),
+    ("Change mesh...", "Alterar malha..."),
+    ("Relative to the bounding box diagonal.", "Relativo à diagonal da caixa delimitadora."),
     ("Remove", "Remover"),
     ("Remove channel", "Remover canal"),
     ("Remove effect", "Remover efeito"),

crates/ui-egui/src/i18n/zh_hans.rs

@@ -603,6 +603,8 @@ pub const TABLE: &[(&str, &str)] = &[
     ),
     ("Redo", "重做"),
     ("Reimport mesh", "重新导入网格"),
+    ("Change mesh...", "更换网格..."),
+    ("Relative to the bounding box diagonal.", "相对于包围盒对角线。"),
     ("Remove", "移除"),
     ("Remove channel", "移除通道"),
     ("Remove effect", "移除效果"),

crates/ui-egui/src/lib.rs

@@ -316,7 +316,7 @@ impl TextureCraftApp {
         }
 
         let total = sets.len();
-        self.bake = Some(BakeJob { queue: sets, current: None, total });
+        self.bake = Some(BakeJob { queue: sets, current: None, total, mesh_id: self.session.mesh_id });
     }
 
     /// Re-cook MaterialCraft material layer `layer` in the background. While one cook of the layer
@@ -382,6 +382,15 @@ impl TextureCraftApp {
             return;
         };
 
+        if job.mesh_id != self.session.mesh_id {
+            // The mesh was swapped under the job: stop it and drop its result.
+            if let Some(running) = &job.current {
+                running.progress.cancel.store(true, Ordering::Relaxed);
+            }
+            self.bake = None;
+            return;
+        }
+
         ctx.request_repaint_after(std::time::Duration::from_millis(50));
         if let Some(running) = &job.current {
             let set_index = running.set_index;

crates/ui-egui/src/menus.rs

@@ -57,6 +57,7 @@ pub const CATALOG: &[Item] = &[
     sep("Edit"),
     it("Edit", "Project Configuration...", "ui.projectConfig", None),
     it("Edit", "Reimport mesh", "file.reimportMesh", Some("Ctrl+Shift+R")),
+    it("Edit", "Change mesh...", "file.changeMesh", None),
     it("Edit", "Settings...", "ui.settings", None),
     it("Mode", "Bake Mesh Maps", "ui.mode.bake", Some("F8")),
     it("Mode", "Painting", "ui.mode.paint", Some("F9")),

crates/ui-egui/src/updates_ui.rs

@@ -263,7 +263,7 @@ mod tests {
         assert!(!safe_to_close(h.state()), "unsaved changes");
         h.state_mut().session.modified = false;
 
-        h.state_mut().bake = Some(crate::BakeJob { queue: Vec::new(), current: None, total: 0 });
+        h.state_mut().bake = Some(crate::BakeJob { queue: Vec::new(), current: None, total: 0, mesh_id: 0 });
         assert!(!safe_to_close(h.state()), "a bake");
         h.state_mut().bake = None;
 

crates/ui-egui/src/windows.rs

@@ -921,6 +921,16 @@ pub fn file_action(app: &mut TextureCraftApp, _ctx: &egui::Context, id: &str) ->
             });
             true
         }
+        "file.changeMesh" => {
+            // Layers and texture sets stay; the strokes follow the surface onto the new mesh.
+            let dialog = FileDialog::open().filter(tr("3D meshes"), &texturecraft_engine::formats::mesh_import::MESH_EXTENSIONS);
+            app.ask_file(dialog, Bound::Project, |app, paths| {
+                if let Some(p) = paths.first() {
+                    app.run("file.changeMesh", json!({"path": p.display().to_string()}));
+                }
+            });
+            true
+        }
         _ => false,
     }
 }