From ab554f277f6552de983ed35bfcbbff4cb85a6be5 Mon Sep 17 00:00:00 2001 From: Nexoniarz Date: Wed, 21 Oct 2026 07:58:43 +0200 Subject: [PATCH] Crease (Shift+E): picked edges stay sharp when the shape's smoothed (carried through each level and the mirror; saved); shown in magenta; tests Co-Authored-By: Claude Opus 5.5 --- src/app.cpp | 34 ++++++++++++++++++++++++++++++++++ src/mesh.h | 5 +++-- src/scene.cpp | 30 ++++++++++++++++++++++++++++-- src/scene.h | 2 ++ src/tools.cpp | 21 +++++++++++++++++++-- tests/mesh_test.cpp | 22 ++++++++++++++++++++++ 6 files changed, 108 insertions(+), 6 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index 3b87057..78459d4 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -5431,6 +5431,7 @@ private: if (key(ImGuiKey_F12)) dialog(5); if (key(ImGuiKey_Q)) setTool(Tool::Select); if (key(ImGuiKey_W)) setTool(Tool::Move); + if (key(ImGuiKey_E) && shift && mode_ == Mode::Edit) return creaseSelected(); if (key(ImGuiKey_E)) setTool(Tool::Rotate); if (key(ImGuiKey_R)) setTool(Tool::Scale); if (key(ImGuiKey_D)) setTool(Tool::Draw); @@ -5790,6 +5791,16 @@ private: lines(*ed, shownMesh(*ed), IM_COL32(20, 20, 25, 70), 1.0f, false); lines(*ed, ed->mesh, shading() == Shading::Wire ? IM_COL32(230, 230, 235, 230) : IM_COL32(12, 12, 15, 235), 1.3f, true); } + if (ed && !ed->creases.empty()) { // (creased edges: smoothing keeps them sharp) + const glm::mat4 m = objectMatrix(*ed); + const int n = int(ed->mesh.verts.size()); + for (auto [a, b] : ed->creases) { + ImVec2 sa, sb; + if (a < n && b < n && (xray_ || (pointSeen(*ed, a) && pointSeen(*ed, b))) && project(glm::vec3(m * glm::vec4(ed->mesh.verts[size_t(a)], 1.0f)), sa) && + project(glm::vec3(m * glm::vec4(ed->mesh.verts[size_t(b)], 1.0f)), sb)) + dl->AddLine(sa, sb, IM_COL32(230, 70, 200, 255), 2.5f); + } + } if (Object* o = ed) { const glm::mat4 m = objectMatrix(*o); if (elem_ == Elem::Vertex) { @@ -6151,6 +6162,7 @@ private: add("shape.bridge", "Bridge two faces", "Shape", "", [this] { bridgeNow(); }, editing, "tunnel connect"); add("shape.soft", "Soft selection on / off", "Shape", "Shift+O", [this] { softSel_ = !softSel_; }, {}, "proportional falloff"); add("shape.separate", "Make into its own object", "Shape", "P", [this] { separateSelected(); }, editing, "separate split"); + add("shape.crease", "Crease the picked edges (stay sharp when smoothed)", "Shape", "Shift+E", [this] { creaseSelected(); }, editing, "sharp hard edge subdivision smooth"); add("shape.slide", "Slide the points along their edges...", "Shape", "Alt+G", [this] { startSlide(); }, editing, "edge slide vertex slide"); add("shape.mirror", "Mirror editing (both sides change together)", "Shape", "", [this] { liveMirror_ = !liveMirror_, say(liveMirror_ ? "Mirror editing on: both sides change together" : "Mirror editing off"); }, {}, "symmetry symmetric x"); add("view.solid", "Show: solid", "View", "Z", [this] { shading_ = Shading::Solid; }); @@ -8110,6 +8122,28 @@ private: for (const std::string& d : did) text += (text.empty() ? "" : ", ") + d; say("Repaired: " + text + (still ? std::format(". {} still not closed (see the Print tab)", still) : ". Ready to print")); } + // Crease (Shift+E): the picked edges (or those between picked points / round picked faces) + // kept sharp when the shape's smoothed; again: not. + void creaseSelected() { + Object* o = editing(); + if (!o) return say("Crease works on a shape being edited (Tab)"); + std::set> picked; + if (elem_ == Elem::Edge) + for (auto [a, b] : selEdges_) picked.insert({std::min(a, b), std::max(a, b)}); + else { + const std::set pts = selectedPoints(); + for (const auto& e : adjacencyOf(*o, o->mesh).edges) + if (pts.count(e[0]) && pts.count(e[1])) picked.insert({e[0], e[1]}); + } + if (picked.empty()) return say("Pick the edges to crease first (Edges, 2)"); + pushUndo(); + const bool all = std::all_of(picked.begin(), picked.end(), [&](const auto& e) { return o->creases.count(e) > 0; }); + for (const auto& e : picked) all ? (void)o->creases.erase(e) : (void)o->creases.insert(e); + touched(o->id); + say(all ? std::format("{} edge{} smooth again", picked.size(), picked.size() == 1 ? "" : "s") + : std::format("{} edge{} creased: smoothing keeps {} sharp{}", picked.size(), picked.size() == 1 ? "" : "s", picked.size() == 1 ? "it" : "them", + o->smoothLevels ? "" : " (turn on Smooth out to see)")); + } // Slide (Alt+G): the picked points glide along their edges, each along the edge that goes // most the way the mouse goes, never past its other end. Click: done. Esc / right click: as it was. struct Slide { diff --git a/src/mesh.h b/src/mesh.h index 09f61e7..c204d06 100644 --- a/src/mesh.h +++ b/src/mesh.h @@ -75,8 +75,9 @@ void bevelEdges(Mesh& m, const std::set>& edges, float width // Edges where the faces meet sharper than `angle` degrees. std::set> sharpEdges(const Mesh& m, float angle); // Every face cut into four-sided pieces; `smooth` rounds it (Catmull–Clark) — edges sharper -// than `keepAngle` degrees stay sharp (180: none do). -void subdivide(Mesh& m, bool smooth, float keepAngle = 180.0f); +// than `keepAngle` degrees stay sharp (180: none do), and the `creases` (point pairs, the lower +// first) too: they're made the new edges along them, for the next time round. +void subdivide(Mesh& m, bool smooth, float keepAngle = 180.0f, std::set>* creases = nullptr); // The ring of four-sided faces across an edge, cut round the middle `cuts` times. Returns the new // points (empty if the edge has no four-sided face). std::vector loopCut(Mesh& m, std::pair edge, int cuts = 1); diff --git a/src/scene.cpp b/src/scene.cpp index b08e342..4ee3294 100644 --- a/src/scene.cpp +++ b/src/scene.cpp @@ -113,6 +113,9 @@ void applyMaterial(Object& o, const MaterialPreset& m) { Mesh finishedMesh(const Object& o, bool mirrorOnly) { Mesh m = o.mesh; + std::set> creases; + for (const auto& [a, b] : o.creases) // (only those still edges of its points) + if (a >= 0 && b >= 0 && a < int(m.verts.size()) && b < int(m.verts.size())) creases.insert({std::min(a, b), std::max(a, b)}); for (int axis = 0; axis < 3; ++axis) { if (!(o.mirror & (1 << axis))) continue; glm::vec3 s(1.0f); @@ -127,6 +130,10 @@ Mesh finishedMesh(const Object& o, bool mirrorOnly) { if (std::abs(m.verts[i][axis]) < eps) to[i] = int(i - before); for (auto& f : m.faces) for (int& v : f) v = to[size_t(v)]; + for (const auto& [a, b] : std::set(creases)) { // (the creases mirrored with it) + const int p = to[size_t(a) + before], q = to[size_t(b) + before]; + creases.insert({std::min(p, q), std::max(p, q)}); + } std::erase_if(m.faces, [](const std::vector& f) { return std::set(f.begin(), f.end()).size() < 3; }); // (a face lying on the mirror line would now be there twice, back to back: both go) std::map, int> seen; @@ -140,11 +147,23 @@ Mesh finishedMesh(const Object& o, bool mirrorOnly) { std::sort(k.begin(), k.end()); return seen[k] > 1; }); + { // (the creases numbered as removeUnused is about to number the points) + std::vector num(m.verts.size(), -1); + for (const auto& f : m.faces) + for (int v : f) num[size_t(v)] = 0; + int next = 0; + for (int& n : num) + if (n == 0) n = next++; + std::set> now; + for (const auto& [a, b] : creases) + if (num[size_t(a)] >= 0 && num[size_t(b)] >= 0) now.insert({std::min(num[size_t(a)], num[size_t(b)]), std::max(num[size_t(a)], num[size_t(b)])}); + creases = std::move(now); + } removeUnused(m); } if (mirrorOnly) return m; - if (o.round > 0.0f) bevelEdges(m, sharpEdges(m, o.roundAngle), o.round, o.roundSteps); - for (int i = 0; i < std::min(o.smoothLevels, 4); ++i) subdivide(m, true, o.smoothKeepSharp ? 30.0f : 180.0f); + if (o.round > 0.0f) bevelEdges(m, sharpEdges(m, o.roundAngle), o.round, o.roundSteps), creases.clear(); // (rounded: its points renumbered) + for (int i = 0; i < std::min(o.smoothLevels, 4); ++i) subdivide(m, true, o.smoothKeepSharp ? 30.0f : 180.0f, &creases); return m; } @@ -229,6 +248,11 @@ std::string sceneText(const Scene& scene) { if (o.mirror) out << " mirror " << o.mirror << "\n"; if (o.round > 0.0f) out << " round " << o.round << " " << o.roundSteps << " " << o.roundAngle << "\n"; if (o.smoothLevels) out << " subdivide " << o.smoothLevels << " " << o.smoothKeepSharp << "\n"; + if (!o.creases.empty()) { + out << " crease"; + for (const auto& [a, b] : o.creases) out << " " << a << " " << b; + out << "\n"; + } if (!o.pictureFile.empty()) out << " picture " << quoted(o.pictureFile) << "\n"; for (const PictureLayer& l : o.layers) { if (l.file.empty()) continue; @@ -356,6 +380,8 @@ std::optional parseScene(std::istream& in, const std::string& path, std:: } else if (word == "mirror") l >> o->mirror; else if (word == "round") l >> o->round >> o->roundSteps >> o->roundAngle; else if (word == "subdivide") l >> o->smoothLevels >> o->smoothKeepSharp; + else if (word == "crease") + for (int a, b; l >> a >> b;) o->creases.insert({std::min(a, b), std::max(a, b)}); else if (word == "picture") o->pictureFile = readQuoted(l); else if (word == "layer") { PictureLayer p; diff --git a/src/scene.h b/src/scene.h index b059615..7638b02 100644 --- a/src/scene.h +++ b/src/scene.h @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include @@ -64,6 +65,7 @@ struct Object { int roundSteps = 3; int smoothLevels = 0; bool smoothKeepSharp = false; + std::set> creases; // edges (points, the lower first) smoothing keeps sharp bool hasFinish() const { return mirror || round > 0.0f || smoothLevels > 0; } // A painted picture on it: where each face corner sits on it (0..1), and the picture // (shared with the undo steps until it's painted on again). Saved beside the .fry as a PNG. diff --git a/src/tools.cpp b/src/tools.cpp index 97d84d9..549ad75 100644 --- a/src/tools.cpp +++ b/src/tools.cpp @@ -267,11 +267,11 @@ void bevelEdges(Mesh& m, const std::set>& want, float width, // ── Subdivide (Catmull–Clark) ── -void subdivide(Mesh& m, bool smooth, float keepAngle) { +void subdivide(Mesh& m, bool smooth, float keepAngle, std::set>* creases) { if (m.faces.empty()) return; const auto d = directed(m); const std::set sharp = keepAngle < 179.9f ? sharpEdges(m, keepAngle) : std::set{}; - auto crease = [&](int a, int b) { return !d.count({a, b}) || !d.count({b, a}) || sharp.count(key(a, b)); }; + auto crease = [&](int a, int b) { return !d.count({a, b}) || !d.count({b, a}) || sharp.count(key(a, b)) || (creases && creases->count(key(a, b))); }; Mesh out; out.verts = m.verts; std::vector facePt(m.faces.size()); @@ -317,6 +317,23 @@ void subdivide(Mesh& m, bool smooth, float keepAngle) { for (size_t i = 0; i < n; ++i) out.faces.push_back({fv[i], edgePt[key(fv[i], fv[(i + 1) % n])], facePt[f], edgePt[key(fv[(i + n - 1) % n], fv[i])]}); } + if (creases) { // (each crease is now two edges, through its new middle point; numbered as removeUnused will) + std::vector to(out.verts.size(), -1); + int next = 0; + std::vector used(out.verts.size()); + for (const auto& f : out.faces) + for (int v : f) used[size_t(v)] = true; + for (size_t v = 0; v < used.size(); ++v) + if (used[v]) to[v] = next++; + std::set> now; + for (const auto& [a, b] : *creases) { + const auto it = edgePt.find(key(a, b)); + if (it == edgePt.end()) continue; // (not an edge any more) + for (const auto& [p, q] : {std::pair{a, it->second}, std::pair{it->second, b}}) + if (to[size_t(p)] >= 0 && to[size_t(q)] >= 0) now.insert(key(to[size_t(p)], to[size_t(q)])); + } + *creases = std::move(now); + } m = std::move(out); removeUnused(m); } diff --git a/tests/mesh_test.cpp b/tests/mesh_test.cpp index 80ddabb..40d8419 100644 --- a/tests/mesh_test.cpp +++ b/tests/mesh_test.cpp @@ -449,6 +449,28 @@ int main() { CHECK(checkForPrint(o).closed() && checkForPrint(o).volume < 0.05f * 0.04f * 0.01f, "an O has its hole (%g m3)", checkForPrint(o).volume); CHECK(makeText({}, "x", st, &err).faces.empty() && !err.empty(), "no font: nothing, and why"); } + // Creases: a cube smoothed with all its edges creased stays a cube; with none it rounds off; + // mirrored, the copy's creases hold too; and they're saved. + { + Object o; + o.id = 1, o.mesh = makeCube(1.0f), o.smoothLevels = 2; + const float round = checkForPrint(finishedMesh(o)).volume; + for (auto [a, b] : edges(o.mesh)) o.creases.insert({a, b}); + const float kept = checkForPrint(finishedMesh(o)).volume; + CHECK(round < 0.8f && std::abs(kept - 1.0f) < 1e-4f, "creased all round: still a cube (%.3f; smooth %.3f)", kept, round); + Object half; + half.id = 2, half.mesh = makeCube(1.0f), half.smoothLevels = 2, half.mirror = 1; + transform(half.mesh, glm::translate(glm::mat4(1), glm::vec3(0.5f, 0, 0))); + for (auto [a, b] : edges(half.mesh)) half.creases.insert({a, b}); + const float both = checkForPrint(finishedMesh(half)).volume; + CHECK(std::abs(both - 2.0f) < 1e-3f, "mirrored, creased: two cubes' worth, square (%.3f)", both); + Scene sc; + sc.objects.push_back(o); + const auto file = (std::filesystem::temp_directory_path() / "fry3dx_test" / "crease.fry").string(); + std::filesystem::create_directories(std::filesystem::path(file).parent_path()); + auto back = saveScene(file, sc) ? loadScene(file) : std::nullopt; + CHECK(back && back->objects.size() == 1 && back->objects[0].creases == o.creases, "creases saved and back"); + } // A slicer's layer: a 1 m cube cut halfway is a 4 m outline, a cylinder's a circle's. { float len = 0;