Free, open-source 3D sculpting for Linux, macOS and Windows: dense meshes, remeshing, painting, built-in AI (image/text to 3D), Send to Unreal, game-ready LODs, Gaussian splats and OpenUSD.
C++ 3d3d-sculptingcppdear-imguidigital-sculptingfbxgame-developmentgaussian-splattinggltfimage-to-3dmcpopenglopenusdsculptingtext-to-3dunreal-engine
Sculpt layers on subdivision levels: tests for recording at the top, stepping, weights, Divide, Reconstruct, Del Lower/Higher, undo, projects and blend-shape export (all already work); Layers panel Ctrl-hover help; UI test
islandmed9a764fbf8e77
diff --git a/src/app/App.cpp b/src/app/App.cppindex 0d0af295..fe82afb9 100644--- a/src/app/App.cpp+++ b/src/app/App.cpp@@ -1331,6 +1331,8 @@ void App::drawLayersContents() {ImGui::TextDisabled("Sculpt expressions & correctives;\nexported as glTF morph targets.");if (ImGui::RadioButton("Base mesh", doc_.activeLayer < 0)) runCommand("layer_set_active", {{"index", -1.0}});+ constexpr const char* kLayersPath = "Tool > Layers";+ ui::HelpText("Base mesh", nullptr, "Strokes go into the base shape, not a layer.", kLayersPath);int removeIndex = -1;for (int i = 0; i < int(doc_.mesh.layers.size()); ++i) {@@ -1339,6 +1341,10 @@ void App::drawLayersContents() {ImGui::Separator();if (ImGui::RadioButton(layer.name.c_str(), doc_.activeLayer == i))runCommand("layer_set_active", {{"index", double(i)}});+ ui::HelpText(layer.name.c_str(), nullptr,+ "Select to sculpt into this layer (ZBrush's REC). With subdivision levels, record at any level: a "+ "layer keeps its own detail on every level and follows Lower Res / Higher Res and Divide.",+ kLayersPath);ImGui::SameLine(ImGui::GetContentRegionAvail().x - 52 * scale);const bool playing = playingLayer_ == i;if (ImGui::SmallButton(playing ? "Stop" : "Play")) {@@ -1346,15 +1352,21 @@ void App::drawLayersContents() {playTime_ = 0.0f;if (playing) setLayerWeight(i, 1.0f);}- if (ImGui::IsItemHovered()) ImGui::SetTooltip("Animate this blend shape 0 -> 1 -> 0");+ ui::HelpText(playing ? "Stop" : "Play", nullptr, "Animate this blend shape 0 -> 1 -> 0 (Stop sets it back to 1).",+ kLayersPath);ImGui::SameLine();if (ImGui::SmallButton("X")) removeIndex = i;+ ui::HelpText("Delete layer", nullptr, "Delete this layer on every subdivision level (undoable).", kLayersPath);float w = layer.weight;ImGui::SetNextItemWidth(-1);if (ImGui::SliderFloat("##weight", &w, 0.0f, 1.0f, "weight %.2f")) {if (playingLayer_ == i) playingLayer_ = -1;setLayerWeight(i, w);}+ ui::HelpText("Weight", nullptr,+ "How strongly the layer shows: 0 = off (ZBrush's eye), 1 = as sculpted. One weight for every "+ "subdivision level.",+ kLayersPath);ImGui::PopID();}if (removeIndex >= 0) {@@ -1369,6 +1381,7 @@ void App::drawLayersContents() {ImGuiInputTextFlags_EnterReturnsTrue);ImGui::SameLine();if (ImGui::Button("+ Add") || enter) runCommand("layer_add", {{"name", std::string(newLayerName_)}});+ ui::HelpText("+ Add", nullptr, "Add a sculpt layer with the name typed beside it; strokes go into it.", kLayersPath);}void App::sendToUnreal() {diff --git a/tests/test_multires_layers.cpp b/tests/test_multires_layers.cppnew file mode 100644index 00000000..e5f4f0ff--- /dev/null+++ b/tests/test_multires_layers.cpp@@ -0,0 +1,439 @@+// SculptForge - open source digital sculpting+// SPDX-License-Identifier: GPL-3.0-or-later+//+// Sculpt layers on subdivision levels, as ZBrush's 3D Layers: a layer recorded at the top level survives stepping+// down and up, Divide, Reconstruct Subdiv, Del Lower / Del Higher, saving and loading, and stays togglable and+// blendable at every level; layers added or sculpted at a low level show at the top; undo across levels; blend+// shapes export from the current level.+#include "TestHarness.h"++#include "core/Commands.h"+#include "core/Multires.h"+#include "core/Primitives.h"+#include "core/Project.h"+#include "io/GltfIO.h"++#include <algorithm>+#include <cmath>+#include <cstring>+#include <filesystem>++using namespace sf;++namespace {++const CommandRegistry& registry() {+ static CommandRegistry r;+ return r;+}++CommandResult run(Document& d, const std::string& name, const Args& a = {}) {+ CommandResult r = registry().execute(d, name, a);+ if (!r.ok) std::printf(" (%s: %s)\n", name.c_str(), r.message.c_str());+ return r;+}++// `passes` strokes towards -z through `points`.+bool stroke(Document& d, const std::string& points, const std::string& brush = "Standard", double radius = 0.25,+ double strength = 1.0, int passes = 4) {+ bool ok = true;+ for (int i = 0; i < passes; ++i)+ ok &= run(d, "stroke", {{"points", points}, {"brush", brush}, {"radius", radius}, {"strength", strength}}).ok;+ return ok;+}++float maxDistance(const std::vector<glm::vec3>& a, const std::vector<glm::vec3>& b) {+ if (a.size() != b.size()) return 1e30f;+ float m = 0.0f;+ for (size_t i = 0; i < a.size(); ++i) m = std::max(m, glm::length(a[i] - b[i]));+ return m;+}++float maxLength(const std::vector<glm::vec3>& a) {+ float m = 0.0f;+ for (const auto& v : a) m = std::max(m, glm::length(v));+ return m;+}++bool bitEqual(const std::vector<glm::vec3>& a, const std::vector<glm::vec3>& b) {+ return a.size() == b.size() && (a.empty() || std::memcmp(a.data(), b.data(), a.size() * sizeof(glm::vec3)) == 0);+}++// positions == base + sum(weight * delta)+float layerMismatch(const Mesh& m) {+ if (m.layers.empty()) return 0.0f;+ float worst = 0.0f;+ for (size_t v = 0; v < m.vertexCount(); ++v) {+ glm::vec3 p = m.base[v];+ for (const SculptLayer& l : m.layers) p += l.weight * l.delta[v];+ worst = std::max(worst, glm::length(p - m.positions[v]));+ }+ return worst;+}++// A cube divided `levels` times (Catmull-Clark), a base stroke, then a layer "Smile" recorded at the top.+Document layeredCube(int levels) {+ Document d = makeDoc(makeCube(3));+ for (int i = 0; i < levels; ++i) run(d, "subdiv_divide");+ stroke(d, "-0.4,0.3,2 0.4,0.3,2", "Standard", 0.2);+ run(d, "layer_add", {{"name", "Smile"}});+ d.activeLayer = 0;+ stroke(d, "0,-0.2,2", "Standard", 0.3);+ stroke(d, "-0.3,-0.3,2 0.3,-0.35,2", "Crease", 0.1);+ return d;+}++} // namespace++TEST(layers_levels_record_at_top_step_down_and_up) {+ Document d = layeredCube(3);+ CHECK(subdivLevelText(d.mesh) == "SDiv 4/4");+ CHECK(d.mesh.layers.size() == 1);+ const std::vector<glm::vec3> top = d.mesh.positions, base = d.mesh.base, delta = d.mesh.layers[0].delta;+ CHECK(maxLength(delta) > 0.02f);+ CHECK(layerMismatch(d.mesh) < 1e-6f);+ for (int level = 3; level >= 1; --level) {+ CHECK(run(d, "subdiv_level", {{"level", double(level)}}).ok);+ CHECK(d.mesh.layers.size() == 1 && d.mesh.layers[0].name == "Smile");+ CHECK(layerMismatch(d.mesh) < 1e-5f);+ }+ // The low level shows the layer too (its broad part), and can switch it off and on.+ const std::vector<glm::vec3> low = d.mesh.positions;+ CHECK(maxLength(d.mesh.layers[0].delta) > 0.0f);+ CHECK(run(d, "layer_set_weight", {{"index", 0.0}, {"weight", 0.0}}).ok);+ CHECK(maxDistance(d.mesh.positions, d.mesh.base) < 1e-6f);+ CHECK(run(d, "layer_set_weight", {{"index", 0.0}, {"weight", 1.0}}).ok);+ CHECK(maxDistance(d.mesh.positions, low) < 1e-5f);+ CHECK(run(d, "subdiv_level", {{"level", 4.0}}).ok);+ // Untouched below: back bit for bit.+ CHECK(bitEqual(d.mesh.positions, top));+ CHECK(bitEqual(d.mesh.base, base));+ CHECK(bitEqual(d.mesh.layers[0].delta, delta));+}++TEST(layers_levels_low_level_shows_the_layer_as_the_base_would) {+ // The same strokes at the top into a layer or into the base: every lower level shows the layer exactly as it+ // would show the base change (the layer is restricted to the low levels the way the shape is).+ Document a = makeDoc(makeCube(3)), b = makeDoc(makeCube(3));+ for (Document* d : {&a, &b}) {+ run(*d, "subdiv_divide");+ run(*d, "subdiv_divide");+ }+ std::vector<std::vector<glm::vec3>> plain(3);+ for (int level = 2; level >= 0; --level) plain[size_t(level)] = subdivLevelMesh(b.mesh, level).positions;+ CHECK(run(a, "layer_add", {{"name", "Smile"}}).ok);+ a.activeLayer = 0;+ for (Document* d : {&a, &b}) {+ stroke(*d, "0,-0.2,2", "Standard", 0.3);+ stroke(*d, "-0.3,-0.3,2 0.3,-0.35,2", "Crease", 0.1);+ }+ CHECK(maxDistance(a.mesh.positions, b.mesh.positions) < 1e-5f);+ for (int level = 2; level >= 1; --level) {+ CHECK(run(a, "subdiv_level", {{"level", double(level)}}).ok);+ CHECK(run(b, "subdiv_level", {{"level", double(level)}}).ok);+ std::vector<glm::vec3> change(b.mesh.positions.size());+ for (size_t v = 0; v < change.size(); ++v) change[v] = b.mesh.positions[v] - plain[size_t(level - 1)][v];+ std::printf(" SDiv %d: layer %.4f, base change %.4f, differ by %.2g; base untouched %.2g\n", level,+ maxLength(a.mesh.layers[0].delta), maxLength(change), maxDistance(a.mesh.layers[0].delta, change),+ maxDistance(a.mesh.base, plain[size_t(level - 1)]));+ CHECK(maxDistance(a.mesh.layers[0].delta, change) < 1e-4f);+ CHECK(maxDistance(a.mesh.base, plain[size_t(level - 1)]) < 1e-5f);+ CHECK(maxDistance(a.mesh.positions, b.mesh.positions) < 1e-4f);+ }+}++TEST(layers_levels_weights_blend_at_every_level) {+ Document d = layeredCube(2);+ const std::vector<glm::vec3> base = d.mesh.base, delta = d.mesh.layers[0].delta;+ // Half the layer, set at the bottom: the top shows half of it.+ CHECK(run(d, "subdiv_level", {{"level", 1.0}}).ok);+ CHECK(run(d, "layer_set_weight", {{"index", 0.0}, {"weight", 0.5}}).ok);+ CHECK(layerMismatch(d.mesh) < 1e-5f);+ CHECK(run(d, "subdiv_level", {{"level", 3.0}}).ok);+ CHECK(d.mesh.layers[0].weight == 0.5f);+ CHECK(maxDistance(d.mesh.base, base) < 1e-5f);+ CHECK(maxDistance(d.mesh.layers[0].delta, delta) < 1e-5f);+ CHECK(layerMismatch(d.mesh) < 1e-5f);+ // Exaggerated (weight 2) and off at the top.+ CHECK(run(d, "layer_set_weight", {{"index", 0.0}, {"weight", 2.0}}).ok);+ CHECK(layerMismatch(d.mesh) < 1e-5f);+ CHECK(run(d, "subdiv_level", {{"level", 2.0}}).ok);+ CHECK(layerMismatch(d.mesh) < 1e-5f);+ CHECK(run(d, "subdiv_level", {{"level", 3.0}}).ok);+ CHECK(maxDistance(d.mesh.layers[0].delta, delta) < 1e-5f);+}++TEST(layers_levels_divide_with_layers) {+ Document d = layeredCube(2);+ const std::vector<glm::vec3> top = d.mesh.positions;+ const size_t tris = d.mesh.triangleCount();+ CHECK(run(d, "subdiv_divide").ok);+ CHECK(subdivLevelText(d.mesh) == "SDiv 4/4");+ CHECK(d.mesh.triangleCount() == tris * 4);+ CHECK(d.mesh.layers.size() == 1);+ CHECK(layerMismatch(d.mesh) < 1e-5f);+ // The new level carries the layer: switching it off at the new top takes the stroke away.+ const float on = maxLength(d.mesh.layers[0].delta);+ std::printf(" layer after Divide: %.4f\n", on);+ CHECK(on > 0.02f);+ CHECK(run(d, "subdiv_level", {{"level", 3.0}}).ok);+ CHECK(maxDistance(d.mesh.positions, top) < 1e-5f); // the level divided from is as it was+ // Divide from a lower level steps to the top first.+ CHECK(run(d, "subdiv_level", {{"level", 1.0}}).ok);+ CHECK(run(d, "subdiv_divide").ok);+ CHECK(subdivLevelText(d.mesh) == "SDiv 5/5");+ CHECK(d.mesh.layers.size() == 1 && layerMismatch(d.mesh) < 1e-5f);+ // A layer added at the top after dividing, and one more division.+ CHECK(run(d, "layer_add", {{"name", "Blink"}}).ok);+ d.activeLayer = 1;+ CHECK(stroke(d, "0.3,0.3,2", "Inflate", 0.15));+ CHECK(run(d, "subdiv_level", {{"level", 2.0}}).ok);+ CHECK(d.mesh.layers.size() == 2 && layerMismatch(d.mesh) < 1e-5f);+ CHECK(maxLength(d.mesh.layers[1].delta) > 0.0f);+}++TEST(layers_levels_added_or_sculpted_low_show_at_the_top) {+ Document d = layeredCube(2);+ const std::vector<glm::vec3> topDelta = d.mesh.layers[0].delta;+ // A new layer added and sculpted at SDiv 1.+ CHECK(run(d, "subdiv_level", {{"level", 1.0}}).ok);+ CHECK(run(d, "layer_add", {{"name", "Jaw"}}).ok);+ d.activeLayer = 1;+ CHECK(stroke(d, "-0.2,-0.4,2 0.2,-0.4,2", "Standard", 0.4));+ const float lowJaw = maxLength(d.mesh.layers[1].delta);+ CHECK(lowJaw > 0.01f);+ CHECK(run(d, "subdiv_level", {{"level", 3.0}}).ok);+ CHECK(d.mesh.layers.size() == 2 && d.mesh.layers[1].name == "Jaw");+ CHECK(layerMismatch(d.mesh) < 1e-5f);+ std::printf(" Jaw: %.3f at SDiv 1, %.3f at the top\n", lowJaw, maxLength(d.mesh.layers[1].delta));+ CHECK(maxLength(d.mesh.layers[1].delta) > 0.5f * lowJaw);+ CHECK(maxDistance(d.mesh.layers[0].delta, topDelta) < 1e-5f); // the other layer is untouched+ // The Smile layer sculpted further at SDiv 2 keeps its top-level detail and adds the broad change.+ CHECK(run(d, "subdiv_level", {{"level", 2.0}}).ok);+ d.activeLayer = 0;+ CHECK(stroke(d, "0.35,0.35,2 0.45,0.45,2", "Standard", 0.3));+ CHECK(run(d, "subdiv_level", {{"level", 3.0}}).ok);+ CHECK(layerMismatch(d.mesh) < 1e-5f);+ float changed = 0.0f, kept = 0.0f;+ for (size_t v = 0; v < topDelta.size(); ++v) {+ const float dv = glm::length(d.mesh.layers[0].delta[v] - topDelta[v]);+ if (d.mesh.positions[v].x > 0.2f && d.mesh.positions[v].y > 0.2f) changed = std::max(changed, dv);+ else if (d.mesh.positions[v].x < -0.2f) kept = std::max(kept, dv);+ }+ std::printf(" Smile after a stroke at SDiv 2: %.3f where it went, %.2g far away\n", changed, kept);+ CHECK(changed > 0.01f && kept < 1e-4f);+ // Removing a layer at a low level removes it everywhere.+ CHECK(run(d, "subdiv_level", {{"level", 1.0}}).ok);+ CHECK(run(d, "layer_remove", {{"index", 1.0}}).ok);+ CHECK(run(d, "subdiv_level", {{"level", 3.0}}).ok);+ CHECK(d.mesh.layers.size() == 1 && d.mesh.layers[0].name == "Smile");+ CHECK(layerMismatch(d.mesh) < 1e-5f);+}++TEST(layers_levels_base_edit_low_keeps_the_layer_on_top) {+ // Reshape the base at SDiv 1 (no layer active): the top keeps its layer, riding on the new shape.+ Document d = layeredCube(2);+ const std::vector<glm::vec3> delta = d.mesh.layers[0].delta;+ CHECK(run(d, "subdiv_level", {{"level", 1.0}}).ok);+ d.activeLayer = -1;+ const std::vector<glm::vec3> lowBase = d.mesh.base;+ CHECK(stroke(d, "-0.3,-0.4,2 0.3,-0.4,2", "Standard", 0.5));+ CHECK(maxDistance(d.mesh.base, lowBase) > 0.02f);+ CHECK(run(d, "subdiv_level", {{"level", 3.0}}).ok);+ CHECK(layerMismatch(d.mesh) < 1e-5f);+ // The layer's offsets only turn with the surface: their lengths stay.+ float worst = 0.0f;+ for (size_t v = 0; v < delta.size(); ++v)+ worst = std::max(worst, std::abs(glm::length(d.mesh.layers[0].delta[v]) - glm::length(delta[v])));+ std::printf(" layer offset lengths changed by %.2g at most\n", worst);+ CHECK(worst < 0.25f * maxLength(delta));+ CHECK(run(d, "layer_set_weight", {{"index", 0.0}, {"weight", 0.0}}).ok);+ CHECK(maxDistance(d.mesh.positions, d.mesh.base) < 1e-6f);+}++TEST(layers_levels_reconstruct_with_layers) {+ // A divided mesh imported as a plain mesh with a layer (as from a glTF with morph targets): Reconstruct+ // finds the lower levels and the layer comes along, exact at the top.+ Document src = layeredCube(2);+ Mesh plain = subdivLevelMesh(src.mesh, 2);+ CHECK(plain.layers.size() == 1);+ const std::vector<glm::vec3> top = plain.positions, delta = plain.layers[0].delta;+ Document d = makeDoc(std::move(plain));+ CHECK(run(d, "subdiv_reconstruct").ok);+ CHECK(subdivLevelText(d.mesh) == "SDiv 1/2");+ CHECK(d.mesh.layers.size() == 1 && layerMismatch(d.mesh) < 1e-5f);+ CHECK(run(d, "subdiv_reconstruct").ok);+ CHECK(subdivLevelText(d.mesh) == "SDiv 1/3");+ CHECK(run(d, "subdiv_level", {{"level", 3.0}}).ok);+ CHECK(maxDistance(d.mesh.positions, top) < 1e-5f);+ CHECK(maxDistance(d.mesh.layers[0].delta, delta) < 1e-5f);+ CHECK(run(d, "layer_set_weight", {{"index", 0.0}, {"weight", 0.0}}).ok);+ CHECK(run(d, "subdiv_level", {{"level", 1.0}}).ok);+ CHECK(maxDistance(d.mesh.positions, d.mesh.base) < 1e-6f);+ CHECK(run(d, "layer_set_weight", {{"index", 0.0}, {"weight", 1.0}}).ok);+ CHECK(run(d, "subdiv_level", {{"level", 3.0}}).ok);+ CHECK(maxDistance(d.mesh.positions, top) < 1e-5f);+}++TEST(layers_levels_delete_lower_and_higher) {+ Document d = layeredCube(3);+ const std::vector<glm::vec3> top = d.mesh.positions, delta = d.mesh.layers[0].delta;+ CHECK(run(d, "subdiv_level", {{"level", 2.0}}).ok);+ const std::vector<glm::vec3> level2 = d.mesh.positions, delta2 = d.mesh.layers[0].delta;+ CHECK(run(d, "subdiv_delete_lower").ok);+ CHECK(subdivLevelText(d.mesh) == "SDiv 1/3");+ CHECK(maxDistance(d.mesh.positions, level2) < 1e-6f);+ CHECK(maxDistance(d.mesh.layers[0].delta, delta2) < 1e-6f);+ CHECK(run(d, "subdiv_level", {{"level", 3.0}}).ok);+ CHECK(maxDistance(d.mesh.positions, top) < 1e-5f);+ CHECK(maxDistance(d.mesh.layers[0].delta, delta) < 1e-5f);+ CHECK(layerMismatch(d.mesh) < 1e-5f);+ // Del Higher at SDiv 2: that level, layer included, becomes the top.+ CHECK(run(d, "subdiv_level", {{"level", 2.0}}).ok);+ const std::vector<glm::vec3> mid = d.mesh.positions, midDelta = d.mesh.layers[0].delta;+ CHECK(run(d, "subdiv_delete_higher").ok);+ CHECK(subdivLevelText(d.mesh) == "SDiv 2/2");+ CHECK(maxDistance(d.mesh.positions, mid) < 1e-6f && maxDistance(d.mesh.layers[0].delta, midDelta) < 1e-6f);+ CHECK(run(d, "subdiv_level", {{"level", 1.0}}).ok);+ CHECK(run(d, "subdiv_level", {{"level", 2.0}}).ok);+ CHECK(maxDistance(d.mesh.positions, mid) < 1e-5f && layerMismatch(d.mesh) < 1e-5f);+ // Undo brings both back.+ CHECK(run(d, "undo").ok);+ CHECK(run(d, "undo").ok);+ CHECK(run(d, "undo").ok);+ CHECK(subdivLevelText(d.mesh) == "SDiv 2/3");+ CHECK(run(d, "subdiv_level", {{"level", 3.0}}).ok);+ CHECK(maxDistance(d.mesh.positions, top) < 1e-5f && maxDistance(d.mesh.layers[0].delta, delta) < 1e-5f);+}++TEST(layers_levels_undo_across_levels) {+ Document d = layeredCube(2);+ const std::vector<glm::vec3> top = d.mesh.positions, delta = d.mesh.layers[0].delta;+ CHECK(run(d, "subdiv_level", {{"level", 1.0}}).ok);+ d.activeLayer = 0;+ const std::vector<glm::vec3> lowBefore = d.mesh.layers[0].delta;+ CHECK(stroke(d, "-0.2,-0.4,2 0.2,-0.4,2", "Standard", 0.4));+ std::printf(" low stroke into the layer: %.4f at SDiv 1\n", maxDistance(d.mesh.layers[0].delta, lowBefore));+ CHECK(run(d, "subdiv_level", {{"level", 3.0}}).ok);+ std::printf(" and %.4f at the top\n", maxDistance(d.mesh.layers[0].delta, delta));+ CHECK(maxDistance(d.mesh.layers[0].delta, delta) > 1e-2f);+ // Undo the level step and the low stroke (four passes): back to the top as it was.+ CHECK(run(d, "undo").ok);+ CHECK(subdivLevelText(d.mesh) == "SDiv 1/3");+ for (int i = 0; i < 4; ++i) CHECK(run(d, "undo").ok);+ CHECK(run(d, "subdiv_level", {{"level", 3.0}}).ok);+ CHECK(maxDistance(d.mesh.positions, top) < 1e-5f);+ CHECK(maxDistance(d.mesh.layers[0].delta, delta) < 1e-5f);+ // Undoing the layer's creation at the top (with levels) removes it everywhere.+ Document e = makeDoc(makeCube(3));+ run(e, "subdiv_divide");+ CHECK(run(e, "layer_add", {{"name", "Temp"}}).ok);+ CHECK(run(e, "undo").ok);+ CHECK(e.mesh.layers.empty());+ CHECK(run(e, "subdiv_level", {{"level", 1.0}}).ok);+ CHECK(e.mesh.layers.empty());+}++TEST(layers_levels_project_round_trip) {+ Document d = layeredCube(3);+ run(d, "layer_add", {{"name", "Blink"}});+ d.activeLayer = 1;+ stroke(d, "0.3,0.4,2", "Inflate", 0.15);+ run(d, "layer_set_weight", {{"index", 1.0}, {"weight", 0.7}});+ std::vector<std::vector<glm::vec3>> pos(5), del0(5), del1(5);+ for (int level = 4; level >= 1; --level) {+ CHECK(run(d, "subdiv_level", {{"level", double(level)}}).ok);+ pos[size_t(level)] = d.mesh.positions;+ del0[size_t(level)] = d.mesh.layers[0].delta;+ del1[size_t(level)] = d.mesh.layers[1].delta;+ }+ // Saved at the bottom (the levels above stored as they are) and at the top.+ for (int savedAt : {1, 4}) {+ CHECK(run(d, "subdiv_level", {{"level", double(savedAt)}}).ok);+ const std::string path = tempPath("sf_layers_levels.sfproj");+ std::string err;+ CHECK(saveProject(path, d, err));+ Document e;+ CHECK(loadProject(path, e, err));+ std::filesystem::remove(path);+ CHECK(subdivLevelCount(e.mesh) == 4 && subdivCurrentLevel(e.mesh) == savedAt - 1);+ CHECK(e.mesh.layers.size() == 2 && e.mesh.layers[1].name == "Blink" && e.mesh.layers[1].weight == 0.7f);+ float worst = 0.0f;+ for (int level = 1; level <= 4; ++level) {+ CHECK(run(e, "subdiv_level", {{"level", double(level)}}).ok);+ worst = std::max({worst, maxDistance(e.mesh.positions, pos[size_t(level)]),+ maxDistance(e.mesh.layers[0].delta, del0[size_t(level)]),+ maxDistance(e.mesh.layers[1].delta, del1[size_t(level)])});+ CHECK(layerMismatch(e.mesh) < 1e-5f);+ }+ std::printf(" saved at SDiv %d: levels and layers within %.2g after loading\n", savedAt, worst);+ CHECK(worst < 1e-5f);+ }+}++TEST(layers_levels_export_blend_shapes) {+ // Export writes the current level with its layers as morph targets: the top for the game mesh, a low level+ // for a light one.+ Document d = layeredCube(2);+ for (int level : {3, 1}) {+ CHECK(run(d, "subdiv_level", {{"level", double(level)}}).ok);+ const std::string path = tempPath("sf_layers_levels.glb");+ CHECK(run(d, "export_glb", {{"path", path}}).ok);+ Mesh m;+ std::string err;+ CHECK(loadGltf(path, m, err));+ std::filesystem::remove(path);+ CHECK(m.vertexCount() == d.mesh.vertexCount());+ CHECK(m.layers.size() == 1 && m.layers[0].name == "Smile");+ if (m.layers.size() != 1) continue;+ // Same offsets (by position: the importer may reorder vertices).+ double sumA = 0.0, sumB = 0.0;+ for (const auto& v : m.layers[0].delta) sumA += glm::length(v);+ for (const auto& v : d.mesh.layers[0].delta) sumB += glm::length(v);+ std::printf(" SDiv %d: %zu vertices, morph target total %.4f vs layer %.4f\n", level, m.vertexCount(), sumA, sumB);+ CHECK(std::abs(sumA - sumB) < 1e-3 * std::max(sumB, 1.0));+ CHECK(std::abs(maxLength(m.layers[0].delta) - maxLength(d.mesh.layers[0].delta)) < 1e-4f);+ }+}+++TEST(layers_levels_subdiv_export_other_levels) {+ // subdiv_export writes another level than the current one with its blend shapes: the base cage from the+ // top, and the top from the base (where the levels above wait to be re-evaluated).+ Document d = layeredCube(2);+ std::vector<std::vector<glm::vec3>> delta(4);+ for (int level = 3; level >= 1; --level) {+ CHECK(run(d, "subdiv_level", {{"level", double(level)}}).ok);+ delta[size_t(level)] = d.mesh.layers[0].delta;+ }+ d.activeLayer = -1;+ CHECK(stroke(d, "-0.2,-0.4,2 0.2,-0.4,2", "Standard", 0.4)); // the levels above are stale now+ for (int from : {1, 3})+ for (int level : {1, 3}) {+ if (from == level) continue;+ CHECK(run(d, "subdiv_level", {{"level", double(from)}}).ok);+ Mesh expect = subdivLevelMesh(d.mesh, level - 1);+ CHECK(expect.layers.size() == 1);+ if (expect.layers.size() != 1) continue;+ const std::string path = tempPath("sf_layers_levels_export.glb");+ CHECK(run(d, "subdiv_export", {{"path", path}, {"level", double(level)}}).ok);+ Mesh m;+ std::string err;+ CHECK(loadGltf(path, m, err));+ std::filesystem::remove(path);+ CHECK(m.vertexCount() == expect.vertexCount());+ CHECK(m.layers.size() == 1);+ if (m.layers.size() != 1) continue;+ double sumA = 0.0, sumB = 0.0;+ for (const auto& v : m.layers[0].delta) sumA += glm::length(v);+ for (const auto& v : expect.layers[0].delta) sumB += glm::length(v);+ std::printf(" from SDiv %d, SDiv %d: morph target total %.4f, layer %.4f (as recorded %.4f)\n", from, level,+ sumA, sumB, [&] {+ double t = 0.0;+ for (const auto& v : delta[size_t(level)]) t += glm::length(v);+ return t;+ }());+ CHECK(std::abs(sumA - sumB) < 1e-3 * std::max(sumB, 1.0));+ CHECK(maxDistance(expect.layers[0].delta, delta[size_t(level)]) < 0.25f * maxLength(delta[size_t(level)]));+ }+}diff --git a/tests/ui/layers_levels.sfui b/tests/ui/layers_levels.sfuinew file mode 100644index 00000000..b2f71c44--- /dev/null+++ b/tests/ui/layers_levels.sfui@@ -0,0 +1,82 @@+# Sculpt layers on subdivision levels (ZBrush's 3D Layers): a layer recorded at the top of a divided box survives+# Lower Res / Higher Res, its weight slider works at every level, Divide carries it to a new level, and undo+# steps back through it all.+run new_sphere subdivisions=1+run subtool_append type=cube name=Box+run subtool_delete index=0+orbit 140 -70+key f+click "Geometry##tool.geometry"+click "Geometry/Reconstruct Subdiv"+click "Geometry/Reconstruct Subdiv"+click "Geometry/Reconstruct Subdiv"+click "Geometry/Reconstruct Subdiv"+click "Geometry/Del Higher"+expect_value triangles == 108+key ctrl+d+key ctrl+d+key ctrl+d+expect_value sdiv_levels == 4+expect_value sdiv == 4++# Record a layer at the top: a new layer, then strokes into it.+click "Layers##tool.layers"+type "Layers/##newlayer" Smile+click "Layers/+ Add"+expect_value layers == 1+expect_status "Smile"+key b+key s+key t+snapshot+stroke 0.3 0.45 0.7 0.5+stroke 0.35 0.6 0.65 0.62+expect_value moved > 50+remember moved_max layer_height++# Its weight slider takes it away and brings it back.+drag_item "Layers/##weight" -400 0+expect_value moved_max < 0.000001+drag_item "Layers/##weight" 400 0+expect_value moved_max >= $layer_height*0.999++# Down to SDiv 1 and back up: still there, exactly.+key shift+d+key shift+d+key shift+d+expect_value sdiv == 1+expect_value layers == 1+shot layer-at-sdiv1+# Off at the lowest level: off at the top too.+drag_item "Layers/##weight" -400 0+key d+key d+key d+expect_value sdiv == 4+expect_value moved_max < 0.000001+drag_item "Layers/##weight" 400 0+expect_value moved_max >= $layer_height*0.999+shot layer-at-top++# Divide with the layer: the new level has it too.+key ctrl+d+expect_value sdiv_levels == 5+expect_value layers == 1+key shift+d+expect_value sdiv == 4+expect_value moved_max >= $layer_height*0.999++# Undo walks back through the level steps and the division.+key ctrl+z+expect_value sdiv == 5+key ctrl+z+expect_value sdiv_levels == 4+expect_value layers == 1++# Ctrl-hover help on the Layers panel.+hold ctrl+hover "Layers/Smile"+expect_help "every level"+hover "Layers/##weight"+expect_help "every subdivision level"+hold none