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
Subdivision levels made by Divide keep no triangles, quads, child maps or parent codes, and no detail next to their positions (stack 74 -> 38 B/triangle; project format 6)
islandmed43dda38db432
diff --git a/src/core/Multires.cpp b/src/core/Multires.cppindex 7fa12285..0ed36fe3 100644--- a/src/core/Multires.cpp+++ b/src/core/Multires.cpp@@ -68,6 +68,44 @@ Mesh leanCopy(const Mesh& m) {}std::shared_ptr<Mesh> leanShared(const Mesh& m) { return std::make_shared<Mesh>(leanCopy(m)); }+bool generatedLevel(const SubdivLevel& l) { return l.topo && l.topo->generated; }++// True when `tris` are exactly the triangles generateFaces makes for `tp` (compared polygon by polygon, in parallel).+bool matchesGenerated(const SubdivTopology& tp, const std::vector<glm::uvec3>& tris);++// What level `l` stores of the working mesh `w` (its current level): every level array, and the triangles and+// quad pairs only when they don't follow from the topology.+std::shared_ptr<Mesh> levelData(const Mesh& w, const SubdivLevel& l) {+ auto out = std::make_shared<Mesh>();+ assignLevelArrays(*out, w);+ if (!generatedLevel(l)) {+ out->triangles = w.triangles;+ return out;+ }+ if (!w.quadPartners.empty()) { // kept only if they differ from the generated pairs+ bool same = w.quadPartners.size() == w.triangles.size() && l.topo->catmullClark;+ for (size_t t = 0; t < w.quadPartners.size() && same; ++t) same = w.quadPartners[t] == uint32_t(t ^ 1);+ if (same) std::vector<uint32_t>().swap(out->quadPartners);+ } else if (l.topo->catmullClark) {+ out->quadPartners.assign(w.triangles.size(), Mesh::kNoQuad); // all pairs removed: keep that+ }+ return out;+}++// The triangles of level `l`: its own, or generated into `scratch`.+const std::vector<glm::uvec3>& levelTriangles(const SubdivLevel& l, std::vector<glm::uvec3>& scratch) {+ if (!generatedLevel(l)) return l.data->triangles;+ generateFaces(*l.topo, scratch, nullptr);+ return scratch;+}++// A working copy of level `l` (no topology yet): its arrays with its triangles and quad pairs.+Mesh levelWorkingCopy(const SubdivLevel& l) {+ Mesh out = leanCopy(*l.data);+ if (generatedLevel(l)) generateFaces(*l.topo, out.triangles, out.quadPartners.empty() ? &out.quadPartners : nullptr);+ return out;+}+// The shape channel subdivision and details work on: the positions, or the layer base while sculpt layers exist.std::vector<glm::vec3>& baseChannel(Mesh& m) { return m.layers.empty() ? m.positions : m.base; }const std::vector<glm::vec3>& baseChannel(const Mesh& m) { return m.layers.empty() ? m.positions : m.base; }@@ -105,18 +143,31 @@ uint32_t polySize(const SubdivTopology& tp, size_t p) { return tp.polyOffsets[p// Polygons, edges and vertex -> edge lists of `coarse` with the given quad pairing (empty = all triangles).// Pairs that aren't valid quads are treated as triangles (and dropped from tp.pairing).-std::shared_ptr<SubdivTopology> buildCoarse(const Mesh& coarse, std::vector<uint32_t> pairing, bool cc, bool smooth) {+// Which edge of triangle t is the diagonal it shares with u (as Mesh::quadDiagonal), on a bare triangle list.+int quadDiagonalOf(const std::vector<glm::uvec3>& tris, uint32_t t, uint32_t u) {+ if (t == u || t >= tris.size() || u >= tris.size()) return -1;+ const glm::uvec3& a = tris[t];+ const glm::uvec3& b = tris[u];+ if (a.x == a.y || a.y == a.z || a.x == a.z || b.x == b.y || b.y == b.z || b.x == b.z) return -1;+ for (int e = 0; e < 3; ++e)+ for (int k = 0; k < 3; ++k)+ if (b[k] == a[(e + 1) % 3] && b[(k + 1) % 3] == a[e]) return b[(k + 2) % 3] == a[(e + 2) % 3] ? -1 : e;+ return -1;+}++std::shared_ptr<SubdivTopology> buildCoarse(const std::vector<glm::uvec3>& triangles, uint32_t nv,+ std::vector<uint32_t> pairing, bool cc, bool smooth) {auto tp = std::make_shared<SubdivTopology>();tp->catmullClark = cc;tp->smooth = smooth;- const uint32_t nv = uint32_t(coarse.vertexCount()), nt = uint32_t(coarse.triangleCount());+ const uint32_t nt = uint32_t(triangles.size());tp->coarseVertices = nv;if (pairing.size() != nt) pairing.clear();bool anyPair = false;for (uint32_t t = 0; t < pairing.size(); ++t) {const uint32_t u = pairing[t];if (u == kNone) continue;- if (u >= nt || pairing[u] != t || coarse.quadDiagonal(t, u) < 0) pairing[t] = kNone;+ if (u >= nt || pairing[u] != t || quadDiagonalOf(triangles, t, u) < 0) pairing[t] = kNone;else anyPair = true;}for (uint32_t t = 0; t < pairing.size(); ++t)@@ -130,7 +181,7 @@ std::shared_ptr<SubdivTopology> buildCoarse(const Mesh& coarse, std::vector<uinttp->polyTris.reserve(nt);for (uint32_t t = 0; t < nt; ++t) {const uint32_t u = pairing.empty() ? kNone : pairing[t];- const glm::uvec3& a = coarse.triangles[t];+ const glm::uvec3& a = triangles[t];if (u == kNone) {for (uint32_t c = 0; c < 3; ++c) {tp->polyVerts.push_back(a[c]);@@ -139,8 +190,8 @@ std::shared_ptr<SubdivTopology> buildCoarse(const Mesh& coarse, std::vector<uinttp->polyTris.push_back({t, kNone});} else {if (u < t) continue;- const int e = coarse.quadDiagonal(t, u);- const glm::uvec3& b = coarse.triangles[u];+ const int e = quadDiagonalOf(triangles, t, u);+ const glm::uvec3& b = triangles[u];uint32_t far = 0;for (uint32_t k = 0; k < 3; ++k)if (b[k] != a[0] && b[k] != a[1] && b[k] != a[2]) far = k;@@ -209,14 +260,20 @@ std::shared_ptr<SubdivTopology> buildCoarse(const Mesh& coarse, std::vector<uint}}for (size_t e = 0; e < faceCount.size(); ++e)- if (faceCount[e] > 2) tp->edgeFaces[e].y = kNone;+ if (faceCount[e] > 2) {+ tp->edgeFaces[e].y = kNone;+ tp->nonManifold = true;+ }tp->vertEdgeOffsets.assign(size_t(nv) + 1, 0);for (const auto& e : tp->edges) {++tp->vertEdgeOffsets[e.x + 1];++tp->vertEdgeOffsets[e.y + 1];}- for (size_t v = 0; v < nv; ++v) tp->vertEdgeOffsets[v + 1] += tp->vertEdgeOffsets[v];+ for (size_t v = 0; v < nv; ++v) {+ tp->maxValence = std::max(tp->maxValence, tp->vertEdgeOffsets[v + 1]);+ tp->vertEdgeOffsets[v + 1] += tp->vertEdgeOffsets[v];+ }tp->vertEdges.resize(tp->vertEdgeOffsets[nv]);{std::vector<uint32_t> cursor(tp->vertEdgeOffsets.begin(), tp->vertEdgeOffsets.end() - 1);@@ -226,80 +283,146 @@ std::shared_ptr<SubdivTopology> buildCoarse(const Mesh& coarse, std::vector<uint}}tp->fineVertices = nv + uint32_t(tp->edges.size()) + (cc ? uint32_t(np) : 0u);+ tp->fineTriangles = cc ? size_t(tp->polyVerts.size()) * 2 : np * 4;return tp;}-// The coarse triangle of polygon `p` that holds side `side`.-uint32_t sideTriangle(const SubdivTopology& tp, const Mesh& coarse, uint32_t p, uint32_t side) {+// The coarse triangle of polygon `p` that holds side `side`: a quad (t[e+1], t[e+2], t[e], far) from buildCoarse+// has sides 0 and 1 on its first triangle and 2 and 3 on the one across the diagonal.+uint32_t sideTriangle(const SubdivTopology& tp, uint32_t p, uint32_t side) {const glm::uvec2 tris = tp.polyTris[p];- if (tris.y == kNone) return tris.x;- const uint32_t o = tp.polyOffsets[p], n = polySize(tp, p);- const uint32_t a = tp.polyVerts[o + side], b = tp.polyVerts[o + (side + 1) % n];- const glm::uvec3& t = coarse.triangles[tris.x];- auto has = [&](uint32_t v) { return t.x == v || t.y == v || t.z == v; };- return has(a) && has(b) ? tris.x : tris.y;+ return tris.y == kNone || side < 2 ? tris.x : tris.y;}-void buildFrameRefs(SubdivTopology& tp, const std::vector<glm::uvec3>& fine) {- tp.frameRef.assign(tp.fineVertices, kNone);+// Per fine vertex: the neighbour that fixes its tangent direction (the next corner in the first triangle that+// has it). Built when details are fitted or applied rather than stored.+std::vector<uint32_t> frameRefs(uint32_t vertices, const std::vector<glm::uvec3>& fine) {+ std::vector<uint32_t> ref(vertices, kNone);for (const auto& t : fine)for (int c = 0; c < 3; ++c)- if (tp.frameRef[t[c]] == kNone) tp.frameRef[t[c]] = t[(c + 1) % 3];+ if (ref[t[c]] == kNone) ref[t[c]] = t[(c + 1) % 3];+ return ref;}-// Fine triangles (with quad pairs) of a freshly divided level, and their parents / corner codes.-void buildDividedFaces(SubdivTopology& tp, const Mesh& coarse, Mesh& fine) {- const uint32_t nv = tp.coarseVertices, ne = uint32_t(tp.edges.size());+// Calls fn(f, polygon, coarse triangle, codes) for every fine triangle f in order (codes: 3 corner codes, see+// SubdivTopology), from the stored parents or, on a generated level, as generateFaces lays the triangles out.+template <class Fn>+void forEachFineFace(const SubdivTopology& tp, Fn fn) {+ if (!tp.generated) {+ for (size_t f = 0; f < tp.fineParentTri.size(); ++f) fn(f, tp.fineParentPoly[f], tp.fineParentTri[f], &tp.fineCode[f * 3]);+ return;+ }+ size_t f = 0;const size_t np = tp.polygonCount();- tp.vertexChild.resize(nv);- for (uint32_t v = 0; v < nv; ++v) tp.vertexChild[v] = v;- tp.edgeChild.resize(ne);- for (uint32_t e = 0; e < ne; ++e) tp.edgeChild[e] = nv + e;- if (tp.catmullClark) {- tp.faceChild.resize(np);- for (uint32_t p = 0; p < np; ++p) tp.faceChild[p] = nv + ne + p;- }- size_t fineCount = 0;- for (size_t p = 0; p < np; ++p) fineCount += tp.catmullClark ? 2 * polySize(tp, p) : 4;- fine.triangles.clear();- fine.triangles.reserve(fineCount);- tp.fineParentPoly.reserve(fineCount);- tp.fineParentTri.reserve(fineCount);- tp.fineCode.reserve(fineCount * 3);- if (tp.catmullClark) fine.quadPartners.assign(fineCount, Mesh::kNoQuad);- auto emit = [&](uint32_t p, uint32_t tri, glm::uvec3 v, uint8_t c0, uint8_t c1, uint8_t c2) {- fine.triangles.push_back(v);- tp.fineParentPoly.push_back(p);- tp.fineParentTri.push_back(tri);- tp.fineCode.insert(tp.fineCode.end(), {c0, c1, c2});- };for (uint32_t p = 0; p < np; ++p) {- const uint32_t o = tp.polyOffsets[p], n = polySize(tp, p);- auto corner = [&](uint32_t i) { return tp.polyVerts[o + i % n]; };- auto edgePt = [&](uint32_t i) { return nv + tp.polyEdges[o + i % n]; };+ const uint32_t n = polySize(tp, p);if (tp.catmullClark) {- const uint32_t f = tp.faceChild[p];for (uint32_t i = 0; i < n; ++i) {- const uint32_t tri = sideTriangle(tp, coarse, p, i), prev = (i + n - 1) % n;- const uint32_t a = uint32_t(fine.triangles.size());- emit(p, tri, {corner(i), edgePt(i), f}, uint8_t(i), uint8_t(4 + i), 8);- emit(p, tri, {corner(i), f, edgePt(prev)}, uint8_t(i), 8, uint8_t(4 + prev));- fine.quadPartners[a] = a + 1;- fine.quadPartners[a + 1] = a;+ const uint32_t tri = sideTriangle(tp, p, i), prev = (i + n - 1) % n;+ const uint8_t a[3] = {uint8_t(i), uint8_t(4 + i), 8}, b[3] = {uint8_t(i), 8, uint8_t(4 + prev)};+ fn(f++, p, tri, a);+ fn(f++, p, tri, b);}} else {+ static constexpr uint8_t codes[4][3] = {{0, 4, 6}, {1, 5, 4}, {2, 6, 5}, {4, 5, 6}};const uint32_t tri = tp.polyTris[p].x;- emit(p, tri, {corner(0), edgePt(0), edgePt(2)}, 0, 4, 6);- emit(p, tri, {corner(1), edgePt(1), edgePt(0)}, 1, 5, 4);- emit(p, tri, {corner(2), edgePt(2), edgePt(1)}, 2, 6, 5);- emit(p, tri, {edgePt(0), edgePt(1), edgePt(2)}, 4, 5, 6);+ for (const auto& c : codes) fn(f++, p, tri, c);}}- buildFrameRefs(tp, fine.triangles);+}++} // namespace++void generateFaces(const SubdivTopology& tp, std::vector<glm::uvec3>& triangles, std::vector<uint32_t>* quadPartners) {+ const uint32_t nv = tp.coarseVertices, ne = uint32_t(tp.edges.size());+ const size_t np = tp.polygonCount();+ std::vector<glm::uvec3>().swap(triangles);+ triangles.resize(tp.fineTriangles);+ if (quadPartners) {+ std::vector<uint32_t>().swap(*quadPartners);+ if (tp.catmullClark) quadPartners->resize(tp.fineTriangles);+ }+ parallelRange(np, [&](size_t b, size_t e) {+ for (size_t p = b; p < e; ++p) {+ const uint32_t o = tp.polyOffsets[p], n = polySize(tp, p);+ auto corner = [&](uint32_t i) { return tp.polyVerts[o + i % n]; };+ auto edgePt = [&](uint32_t i) { return nv + tp.polyEdges[o + i % n]; };+ size_t f = tp.firstFineTriangle(p);+ if (tp.catmullClark) {+ const uint32_t c = nv + ne + uint32_t(p);+ for (uint32_t i = 0; i < n; ++i, f += 2) {+ triangles[f] = {corner(i), edgePt(i), c};+ triangles[f + 1] = {corner(i), c, edgePt(i + n - 1)};+ if (quadPartners) {+ (*quadPartners)[f] = uint32_t(f + 1);+ (*quadPartners)[f + 1] = uint32_t(f);+ }+ }+ } else {+ triangles[f] = {corner(0), edgePt(0), edgePt(2)};+ triangles[f + 1] = {corner(1), edgePt(1), edgePt(0)};+ triangles[f + 2] = {corner(2), edgePt(2), edgePt(1)};+ triangles[f + 3] = {edgePt(0), edgePt(1), edgePt(2)};+ }+ }+ });+}++namespace {++bool matchesGenerated(const SubdivTopology& tp, const std::vector<glm::uvec3>& tris) {+ if (tris.size() != tp.fineTriangles) return false;+ const uint32_t nv = tp.coarseVertices, ne = uint32_t(tp.edges.size());+ std::atomic<bool> same = true;+ parallelRange(tp.polygonCount(), [&](size_t b, size_t e) {+ for (size_t p = b; p < e && same.load(std::memory_order_relaxed); ++p) {+ const uint32_t o = tp.polyOffsets[p], n = polySize(tp, p);+ auto corner = [&](uint32_t i) { return tp.polyVerts[o + i % n]; };+ auto edgePt = [&](uint32_t i) { return nv + tp.polyEdges[o + i % n]; };+ const size_t f = tp.firstFineTriangle(p);+ bool ok = true;+ if (tp.catmullClark) {+ const uint32_t c = nv + ne + uint32_t(p);+ for (uint32_t i = 0; i < n && ok; ++i)+ ok = tris[f + 2 * i] == glm::uvec3(corner(i), edgePt(i), c) &&+ tris[f + 2 * i + 1] == glm::uvec3(corner(i), c, edgePt(i + n - 1));+ } else {+ ok = tris[f] == glm::uvec3(corner(0), edgePt(0), edgePt(2)) && tris[f + 1] == glm::uvec3(corner(1), edgePt(1), edgePt(0)) &&+ tris[f + 2] == glm::uvec3(corner(2), edgePt(2), edgePt(1)) && tris[f + 3] == glm::uvec3(edgePt(0), edgePt(1), edgePt(2));+ }+ if (!ok) same = false;+ }+ });+ return same;+}++// True when the child maps number the fine vertices as a generated level does.+bool canonicalChildren(const SubdivTopology& tp) {+ const uint32_t nv = tp.coarseVertices, ne = uint32_t(tp.edges.size());+ if (tp.vertexChild.size() != nv || tp.edgeChild.size() != ne || tp.faceChild.size() != (tp.catmullClark ? tp.polygonCount() : 0))+ return false;+ for (uint32_t v = 0; v < nv; ++v)+ if (tp.vertexChild[v] != v) return false;+ for (uint32_t e = 0; e < ne; ++e)+ if (tp.edgeChild[e] != nv + e) return false;+ for (uint32_t p = 0; p < tp.faceChild.size(); ++p)+ if (tp.faceChild[p] != nv + ne + p) return false;+ return true;+}++// Makes `tp` a generated level (dropping its child maps and fine parents).+void markGenerated(SubdivTopology& tp) {+ tp.generated = true;+ std::vector<uint32_t>().swap(tp.vertexChild);+ std::vector<uint32_t>().swap(tp.edgeChild);+ std::vector<uint32_t>().swap(tp.faceChild);+ std::vector<uint32_t>().swap(tp.fineParentPoly);+ std::vector<uint32_t>().swap(tp.fineParentTri);+ std::vector<uint8_t>().swap(tp.fineCode);}// Parents and corner codes of arbitrary fine triangles from the child maps (reconstructed or loaded levels).-bool buildFineMetadata(SubdivTopology& tp, const Mesh& coarse, const std::vector<glm::uvec3>& fine, std::string& error) {+bool buildFineMetadata(SubdivTopology& tp, const std::vector<glm::uvec3>& fine, std::string& error) {const uint32_t nf = tp.fineVertices;std::vector<uint8_t> kind(nf, 255);std::vector<uint32_t> id(nf, kNone);@@ -323,6 +446,7 @@ bool buildFineMetadata(SubdivTopology& tp, const Mesh& coarse, const std::vectorreturn false;}const size_t nt = fine.size();+ tp.fineTriangles = nt;tp.fineParentPoly.assign(nt, kNone);tp.fineParentTri.assign(nt, kNone);tp.fineCode.assign(nt * 3, 0);@@ -368,7 +492,7 @@ bool buildFineMetadata(SubdivTopology& tp, const Mesh& coarse, const std::vector}if (side < 0 && e1 >= 0) side = e2 >= 0 && (uint32_t(e1) + 1) % n == uint32_t(e2) ? e2 : e1;tp.fineParentPoly[f] = p;- tp.fineParentTri[f] = sideTriangle(tp, coarse, p, uint32_t(std::max(side, 0)));+ tp.fineParentTri[f] = sideTriangle(tp, p, uint32_t(std::max(side, 0)));for (int c = 0; c < 3; ++c) tp.fineCode[f * 3 + size_t(c)] = codes[c];found = true;break;@@ -380,7 +504,6 @@ bool buildFineMetadata(SubdivTopology& tp, const Mesh& coarse, const std::vectorerror = "the mesh is not a regular subdivision of the level below";return false;}- buildFrameRefs(tp, fine);return true;}@@ -401,7 +524,7 @@ std::vector<T> subdivideField(const SubdivTopology& tp, bool smooth, const std::const uint32_t o = tp.polyOffsets[p], n = polySize(tp, p);for (uint32_t i = 0; i < n; ++i) sum += P[tp.polyVerts[o + i]];fp[p] = sum / float(n);- out[tp.faceChild[p]] = fp[p];+ out[tp.faceChildOf(uint32_t(p))] = fp[p];}});}@@ -419,13 +542,13 @@ std::vector<T> subdivideField(const SubdivTopology& tp, bool smooth, const std::if (!smooth || f.y == kNone) v = (P[va] + P[vb]) * 0.5f;else if (tp.catmullClark) v = (P[va] + P[vb] + fp[f.x] + fp[f.y]) * 0.25f;else v = (P[va] + P[vb]) * 0.375f + (P[opposite(f.x, va, vb)] + P[opposite(f.y, va, vb)]) * 0.125f;- out[tp.edgeChild[i]] = v;+ out[tp.edgeChildOf(uint32_t(i))] = v;}});parallelRange(tp.coarseVertices, [&](size_t b, size_t e) {for (size_t v = b; v < e; ++v) {const T& pv = P[v];- T& o = out[tp.vertexChild[v]];+ T& o = out[tp.vertexChildOf(uint32_t(v))];const uint32_t e0 = tp.vertEdgeOffsets[v], e1 = tp.vertEdgeOffsets[v + 1], n = e1 - e0;if (!smooth || n == 0) {o = pv;@@ -507,25 +630,25 @@ inline void frameAt(glm::vec3 n, const glm::vec3& q, const glm::vec3& qref, glm:// P[k] = Q + Frame(Q) * D, or D = Frame(Q)^-1 (P[k] - Q), with Q = the subdivided coarse shape and n its// normals (fineNormals).-void applyDetail(const SubdivTopology& tp, const std::vector<glm::vec3>& n, const std::vector<glm::vec3>& Q,+void applyDetail(const std::vector<uint32_t>& refs, const std::vector<glm::vec3>& n, const std::vector<glm::vec3>& Q,const std::vector<glm::vec3>& D, std::vector<glm::vec3>& out) {out.resize(Q.size());parallelRange(Q.size(), [&](size_t b0, size_t e0) {for (size_t v = b0; v < e0; ++v) {glm::vec3 t, b, nn;- const uint32_t r = tp.frameRef[v];+ const uint32_t r = refs[v];frameAt(n[v], Q[v], r == kNone ? Q[v] : Q[r], t, b, nn);out[v] = Q[v] + t * D[v].x + b * D[v].y + nn * D[v].z;}});}-void fitDetail(const SubdivTopology& tp, const std::vector<glm::vec3>& n, const std::vector<glm::vec3>& Q,+void fitDetail(const std::vector<uint32_t>& refs, const std::vector<glm::vec3>& n, const std::vector<glm::vec3>& Q,const std::vector<glm::vec3>& P, std::vector<glm::vec3>& D) {D.resize(Q.size());parallelRange(Q.size(), [&](size_t b0, size_t e0) {for (size_t v = b0; v < e0; ++v) {glm::vec3 t, b, nn;- const uint32_t r = tp.frameRef[v];+ const uint32_t r = refs[v];frameAt(n[v], Q[v], r == kNone ? Q[v] : Q[r], t, b, nn);const glm::vec3 d = P[v] - Q[v];D[v] = {glm::dot(d, t), glm::dot(d, b), glm::dot(d, nn)};@@ -535,25 +658,25 @@ void fitDetail(const SubdivTopology& tp, const std::vector<glm::vec3>& n, const// Sculpt-layer details live in the same local frames as the shape's (the frames of Q, the subdivided coarse// base, with normals n = fineNormals(tris, Q)), so they turn with the surface. `out` += Frame(Q) * local.-void addLayerDetail(const SubdivTopology& tp, const std::vector<glm::vec3>& n, const std::vector<glm::vec3>& Q,+void addLayerDetail(const std::vector<uint32_t>& refs, const std::vector<glm::vec3>& n, const std::vector<glm::vec3>& Q,const std::vector<glm::vec3>& local, std::vector<glm::vec3>& out) {parallelRange(Q.size(), [&](size_t b0, size_t e0) {for (size_t v = b0; v < e0; ++v) {glm::vec3 t, b, nn;- const uint32_t r = tp.frameRef[v];+ const uint32_t r = refs[v];frameAt(n[v], Q[v], r == kNone ? Q[v] : Q[r], t, b, nn);out[v] += t * local[v].x + b * local[v].y + nn * local[v].z;}});}// local = Frame(Q)^-1 * world.-void layerDetailToLocal(const SubdivTopology& tp, const std::vector<glm::vec3>& n, const std::vector<glm::vec3>& Q,+void layerDetailToLocal(const std::vector<uint32_t>& refs, const std::vector<glm::vec3>& n, const std::vector<glm::vec3>& Q,const std::vector<glm::vec3>& world, std::vector<glm::vec3>& local) {local.resize(Q.size());parallelRange(Q.size(), [&](size_t b0, size_t e0) {for (size_t v = b0; v < e0; ++v) {glm::vec3 t, b, nn;- const uint32_t r = tp.frameRef[v];+ const uint32_t r = refs[v];frameAt(n[v], Q[v], r == kNone ? Q[v] : Q[r], t, b, nn);const glm::vec3 d = world[v];local[v] = {glm::dot(d, t), glm::dot(d, b), glm::dot(d, nn)};@@ -570,7 +693,7 @@ void restrictVertices(const SubdivTopology& tp, const std::vector<T>& fine, std:if (coarse.size() != tp.coarseVertices) coarse.assign(tp.coarseVertices, fill);outFlags.assign(tp.coarseVertices, 0);for (uint32_t v = 0; v < tp.coarseVertices; ++v) {- const uint32_t f = tp.vertexChild[v];+ const uint32_t f = tp.vertexChildOf(v);if (flags && !(*flags)[f]) continue;coarse[v] = fine[f];outFlags[v] = 1;@@ -588,16 +711,16 @@ void prolongVertices(const SubdivTopology& tp, const std::vector<T>& coarse, stdauto on = [&](uint32_t v) { return !flags || (*flags)[v]; };for (uint32_t v = 0; v < tp.coarseVertices; ++v)if (on(v)) {- fine[tp.vertexChild[v]] = coarse[v];- outFlags[tp.vertexChild[v]] = 1;+ fine[tp.vertexChildOf(v)] = coarse[v];+ outFlags[tp.vertexChildOf(v)] = 1;}for (size_t e = 0; e < tp.edges.size(); ++e) {const uint32_t a = tp.edges[e].x, b = tp.edges[e].y;if (!on(a) && !on(b)) continue;- fine[tp.edgeChild[e]] = (coarse[a] + coarse[b]) * 0.5f;- outFlags[tp.edgeChild[e]] = 1;+ fine[tp.edgeChildOf(uint32_t(e))] = (coarse[a] + coarse[b]) * 0.5f;+ outFlags[tp.edgeChildOf(uint32_t(e))] = 1;}- for (size_t p = 0; p < tp.faceChild.size(); ++p) {+ for (uint32_t p = 0; p < (tp.catmullClark ? tp.polygonCount() : 0); ++p) {const uint32_t o = tp.polyOffsets[p], n = polySize(tp, p);bool any = false;T sum = T(0);@@ -606,8 +729,8 @@ void prolongVertices(const SubdivTopology& tp, const std::vector<T>& coarse, stdsum += coarse[tp.polyVerts[o + i]];}if (!any) continue;- fine[tp.faceChild[p]] = sum / float(n);- outFlags[tp.faceChild[p]] = 1;+ fine[tp.faceChildOf(p)] = sum / float(n);+ outFlags[tp.faceChildOf(p)] = 1;}}@@ -626,7 +749,7 @@ void prolongPaintLayer(const SubdivTopology& tp, const PaintLayer& coarse, Paintfor (uint32_t v = 0; v < tp.fineVertices; ++v)if (outFlags[v]) fine.color[v] = fine.alpha[v] > 0.0f ? fineColor[v] / fine.alpha[v] : glm::vec3(1.0f);for (uint32_t v = 0; v < tp.coarseVertices; ++v)- if (!flags || (*flags)[v]) fine.color[tp.vertexChild[v]] = coarse.color[v]; // corners keep the exact colour+ if (!flags || (*flags)[v]) fine.color[tp.vertexChildOf(v)] = coarse.color[v]; // corners keep the exact colour}template <class T>@@ -634,78 +757,73 @@ void restrictFaces(const SubdivTopology& tp, const std::vector<T>& fine, std::veT fill, const std::vector<uint8_t>* flags, std::vector<uint8_t>& outFlags) {if (coarse.size() != coarseCount) coarse.assign(coarseCount, fill);outFlags.assign(coarseCount, 0);- for (size_t f = 0; f < fine.size(); ++f) {- if (flags && !(*flags)[f]) continue;+ forEachFineFace(tp, [&](size_t f, uint32_t, uint32_t t, const uint8_t* code) {+ if (flags && !(*flags)[f]) return;// The child at a coarse corner speaks for its parent (centre children only when no corner child did).- const uint32_t t = tp.fineParentTri[f];- const bool cornerChild = tp.fineCode[f * 3] < 4 || tp.fineCode[f * 3 + 1] < 4 || tp.fineCode[f * 3 + 2] < 4;- if (outFlags[t] == 2 && !cornerChild) continue;+ const bool cornerChild = code[0] < 4 || code[1] < 4 || code[2] < 4;+ if (outFlags[t] == 2 && !cornerChild) return;coarse[t] = fine[f];outFlags[t] = cornerChild ? 2 : 1;- }+ });for (auto& f : outFlags) f = f ? 1 : 0;}template <class T>void prolongFaces(const SubdivTopology& tp, const std::vector<T>& coarse, std::vector<T>& fine, T fill,const std::vector<uint8_t>* flags, std::vector<uint8_t>& outFlags) {- const size_t nf = tp.fineParentTri.size();+ const size_t nf = tp.fineTriangles;if (fine.size() != nf) {fine.assign(nf, fill);flags = nullptr;}outFlags.assign(nf, 0);- for (size_t f = 0; f < nf; ++f) {- const uint32_t t = tp.fineParentTri[f];- if (flags && !(*flags)[t]) continue;+ forEachFineFace(tp, [&](size_t f, uint32_t, uint32_t t, const uint8_t*) {+ if (flags && !(*flags)[t]) return;fine[f] = coarse[t];outFlags[f] = 1;- }+ });}-// UVs per triangle corner; `flags` are per triangle.-void restrictUvs(const SubdivTopology& tp, const Mesh& coarseMesh, const std::vector<glm::vec2>& fine,+// UVs per triangle corner; `flags` are per triangle. `coarseTris`: the coarse level's triangles.+void restrictUvs(const SubdivTopology& tp, const std::vector<glm::uvec3>& coarseTris, const std::vector<glm::vec2>& fine,std::vector<glm::vec2>& coarse, const std::vector<uint8_t>* flags, std::vector<uint8_t>& outFlags) {- const size_t nt = coarseMesh.triangleCount();+ const size_t nt = coarseTris.size();if (coarse.size() != nt * 3) coarse.assign(nt * 3, glm::vec2(0.0f));outFlags.assign(nt, 0);- for (size_t f = 0; f < tp.fineParentPoly.size(); ++f) {- if (flags && !(*flags)[f]) continue;- const uint32_t p = tp.fineParentPoly[f], o = tp.polyOffsets[p];+ forEachFineFace(tp, [&](size_t f, uint32_t p, uint32_t, const uint8_t* code) {+ if (flags && !(*flags)[f]) return;+ const uint32_t o = tp.polyOffsets[p];for (int c = 0; c < 3; ++c) {- const uint8_t code = tp.fineCode[f * 3 + size_t(c)];- if (code >= 4) continue;- const uint32_t cv = tp.polyVerts[o + code];+ if (code[c] >= 4) continue;+ const uint32_t cv = tp.polyVerts[o + code[c]];for (uint32_t t : {tp.polyTris[p].x, tp.polyTris[p].y}) {if (t == kNone) continue;for (uint32_t s = 0; s < 3; ++s)- if (coarseMesh.triangles[t][s] == cv) {+ if (coarseTris[t][s] == cv) {coarse[t * 3 + s] = fine[f * 3 + size_t(c)];outFlags[t] = 1;}}}- }+ });}void prolongUvs(const SubdivTopology& tp, const std::vector<glm::vec2>& coarse, std::vector<glm::vec2>& fine,const std::vector<uint8_t>* flags, std::vector<uint8_t>& outFlags) {- const size_t nf = tp.fineParentPoly.size();+ const size_t nf = tp.fineTriangles;if (fine.size() != nf * 3) {fine.assign(nf * 3, glm::vec2(0.0f));flags = nullptr;}outFlags.assign(nf, 0);- for (size_t f = 0; f < nf; ++f) {- const uint32_t p = tp.fineParentPoly[f];- if (flags && !(*flags)[tp.polyTris[p].x] && (tp.polyTris[p].y == kNone || !(*flags)[tp.polyTris[p].y])) continue;+ forEachFineFace(tp, [&](size_t f, uint32_t p, uint32_t, const uint8_t* code) {+ if (flags && !(*flags)[tp.polyTris[p].x] && (tp.polyTris[p].y == kNone || !(*flags)[tp.polyTris[p].y])) return;const uint32_t o = tp.polyOffsets[p], n = polySize(tp, p);auto cu = [&](uint32_t i) { return coarse[tp.polyCorner[o + i % n]]; };for (int c = 0; c < 3; ++c) {- const uint8_t code = tp.fineCode[f * 3 + size_t(c)];glm::vec2 uv;- if (code < 4) uv = cu(code);- else if (code < 8) uv = (cu(code - 4u) + cu(code - 3u)) * 0.5f;+ if (code[c] < 4) uv = cu(code[c]);+ else if (code[c] < 8) uv = (cu(code[c] - 4u) + cu(code[c] - 3u)) * 0.5f;else {uv = glm::vec2(0.0f);for (uint32_t i = 0; i < n; ++i) uv += cu(i);@@ -714,12 +832,21 @@ void prolongUvs(const SubdivTopology& tp, const std::vector<glm::vec2>& coarse,fine[f * 3 + size_t(c)] = uv;}outFlags[f] = 1;- }+ });}// --- Levels ----// Shape and sculpt layers of level k from level k-1 and its details.+// Fine normals and frame references of level `l` on the subdivided shape Q, for its details' frames.+void levelFrames(const SubdivLevel& l, const std::vector<glm::vec3>& Q, std::vector<glm::vec3>& n, std::vector<uint32_t>& refs) {+ std::vector<glm::uvec3> scratch;+ const std::vector<glm::uvec3>& tris = levelTriangles(l, scratch);+ n = fineNormals(tris, Q);+ refs = frameRefs(l.topo->fineVertices, tris);+}++// Shape and sculpt layers of level k from level k-1 and its details. Its positions then stand for its detail,+// which is dropped (SubdivLevel::detail).void evaluateLevel(MultiresStack& s, int k) {SubdivLevel& L = s.levels[size_t(k)];const Mesh& coarse = *s.levels[size_t(k) - 1].data;@@ -728,22 +855,37 @@ void evaluateLevel(MultiresStack& s, int k) {const std::vector<glm::vec3> Q = subdivideField(tp, tp.smooth, baseChannel(coarse));std::vector<glm::vec3>& target = baseChannel(fine);std::vector<glm::vec3> n; // normals of Q, for the frames of the details+ std::vector<uint32_t> refs;if (L.detail) {- n = fineNormals(fine.triangles, Q);- applyDetail(tp, n, Q, *L.detail, target);+ levelFrames(L, Q, n, refs);+ applyDetail(refs, n, Q, *L.detail, target);} else {target = Q;}for (size_t i = 0; i < fine.layers.size() && i < coarse.layers.size(); ++i) {std::vector<glm::vec3> d = subdivideField(tp, tp.smooth, coarse.layers[i].delta);if (i < L.layerDetail.size() && L.layerDetail[i]) {- if (n.empty()) n = fineNormals(fine.triangles, Q);- addLayerDetail(tp, n, Q, *L.layerDetail[i], d);+ if (n.empty()) levelFrames(L, Q, n, refs);+ addLayerDetail(refs, n, Q, *L.layerDetail[i], d);}fine.layers[i].delta = std::move(d);}evaluateLayers(fine);L.stale = false;+ L.detail.reset();+}++// Fits the detail of level `L` (not stale, no detail) to its positions on the level below, whose shape channel+// is `coarseBase`: done before that level changes, so this one can follow it.+void fitLevelDetail(SubdivLevel& L, const std::vector<glm::vec3>& coarseBase) {+ const SubdivTopology& tp = *L.topo;+ const std::vector<glm::vec3> Q = subdivideField(tp, tp.smooth, coarseBase);+ std::vector<glm::vec3> n;+ std::vector<uint32_t> refs;+ levelFrames(L, Q, n, refs);+ auto d = std::make_shared<std::vector<glm::vec3>>();+ fitDetail(refs, n, Q, baseChannel(*L.data), *d);+ L.detail = std::move(d);}} // namespace@@ -751,6 +893,7 @@ void evaluateLevel(MultiresStack& s, int k) {struct SubdivLevelCache {struct Entry {std::shared_ptr<Mesh> key; // the level data the mesh was made from (held, so it can't change in place)+ std::shared_ptr<const SubdivTopology> topo; // that level's topology, when generated (its triangles follow)Mesh mesh;BVH bvh;};@@ -761,16 +904,19 @@ struct SubdivLevelCache {namespace {// Makes the working mesh level `level` of its stack (levels up to it must be evaluated). `leaving` is the level-// data the working mesh was (null: don't keep it); with a BVH, that mesh and its BVH go to the level cache and+// the working mesh was (null data: don't keep it); with a BVH, that mesh and its BVH go to the level cache and// a cached copy of the new level is used when there is one.-void enterLevel(Mesh& mesh, int level, BVH* bvh, std::shared_ptr<Mesh> leaving = nullptr) {+void enterLevel(Mesh& mesh, int level, BVH* bvh, const SubdivLevel* leavingLevel = nullptr) {+ std::shared_ptr<Mesh> leaving = leavingLevel ? leavingLevel->data : nullptr;+ std::shared_ptr<const SubdivTopology> leavingTopo = leavingLevel && generatedLevel(*leavingLevel) ? leavingLevel->topo : nullptr;std::shared_ptr<MultiresStack> stack = mesh.multires;if (leaving && leaving == stack->levels[size_t(level)].data) return; // already that level (e.g. Del Lower)if (!stack->cache) stack->cache = std::make_shared<SubdivLevelCache>();SubdivLevelCache& cache = *stack->cache;std::shared_ptr<PaintTexture> texture = mesh.texture;const bool toTexture = mesh.paintToTexture;- const std::shared_ptr<Mesh> want = stack->levels[size_t(level)].data;+ const SubdivLevel& wantLevel = stack->levels[size_t(level)];+ const std::shared_ptr<Mesh> want = wantLevel.data;// A cached copy of this level: exact (same data), or with the same triangles (only the shape or attributes// changed, so its topology and BVH are kept and refitted).std::optional<SubdivLevelCache::Entry> taken;@@ -779,15 +925,16 @@ void enterLevel(Mesh& mesh, int level, BVH* bvh, std::shared_ptr<Mesh> leaving =auto hit = std::find_if(cache.entries.begin(), cache.entries.end(), [&](const auto& e) { return e.key == want; });exact = hit != cache.entries.end();if (!exact)- hit = std::find_if(cache.entries.begin(), cache.entries.end(),- [&](const auto& e) { return sameArray(e.mesh.triangles, want->triangles); });+ hit = std::find_if(cache.entries.begin(), cache.entries.end(), [&](const auto& e) {+ return generatedLevel(wantLevel) ? e.topo == wantLevel.topo : sameArray(e.mesh.triangles, want->triangles);+ });if (hit != cache.entries.end()) {taken = std::move(*hit);cache.entries.erase(hit);}if (leaving) {// Keep the mesh being left (it has its topology and BVH already) for stepping back.- SubdivLevelCache::Entry e{std::move(leaving), std::move(mesh), std::move(*bvh)};+ SubdivLevelCache::Entry e{std::move(leaving), std::move(leavingTopo), std::move(mesh), std::move(*bvh)};e.mesh.multires.reset();e.mesh.texture.reset();cache.entries.push_back(std::move(e));@@ -802,13 +949,17 @@ void enterLevel(Mesh& mesh, int level, BVH* bvh, std::shared_ptr<Mesh> leaving =for (uint32_t v = 0; v < want->positions.size(); ++v)if (want->positions[v] != mesh.positions[v]) moved.push_back(v);assignLevelArrays(mesh, *want);+ if (generatedLevel(wantLevel) && wantLevel.topo->catmullClark && mesh.quadPartners.empty()) {+ mesh.quadPartners.resize(mesh.triangles.size()); // the generated pairs (2i, 2i + 1)+ for (size_t t = 0; t < mesh.quadPartners.size(); ++t) mesh.quadPartners[t] = uint32_t(t ^ 1);+ }mesh.sanitizeAttributes();mesh.recomputeAllNormals();if (hasPaintLayers(mesh)) compositePaintAll(mesh);bvh->refit(mesh, moved);}} else {- mesh = leanCopy(*want);+ mesh = levelWorkingCopy(wantLevel);}mesh.multires = std::move(stack);mesh.texture = std::move(texture);@@ -963,10 +1114,10 @@ void spreadFaceArray(MultiresStack& s, int c, const std::vector<T>& w, const stdstd::vector<uint8_t> flags = changed, next;const std::vector<T>* fine = &w;for (int j = c; j >= 1; --j) {- Mesh& cm = mutableData(s.levels[size_t(j) - 1]);- std::vector<T>& coarse = get(cm);+ const size_t coarseCount = s.levels[size_t(j) - 1].triangleCount();+ std::vector<T>& coarse = get(mutableData(s.levels[size_t(j) - 1]));const bool fresh = coarse.empty();- restrictFaces(*s.levels[size_t(j)].topo, *fine, coarse, cm.triangleCount(), fill, fresh ? nullptr : &flags, next);+ restrictFaces(*s.levels[size_t(j)].topo, *fine, coarse, coarseCount, fill, fresh ? nullptr : &flags, next);flags.swap(next);fine = &coarse;}@@ -998,10 +1149,12 @@ void spreadUvs(MultiresStack& s, int c, const Mesh& w, const Mesh& r) {if (!any) return;std::vector<uint8_t> flags = changed, next;const std::vector<glm::vec2>* fine = &w.uvs;+ std::vector<glm::uvec3> scratch;for (int j = c; j >= 1; --j) {+ const std::vector<glm::uvec3>& coarseTris = levelTriangles(s.levels[size_t(j) - 1], scratch);Mesh& cm = mutableData(s.levels[size_t(j) - 1]);const bool fresh = cm.uvs.empty();- restrictUvs(*s.levels[size_t(j)].topo, cm, *fine, cm.uvs, fresh ? nullptr : &flags, next);+ restrictUvs(*s.levels[size_t(j)].topo, coarseTris, *fine, cm.uvs, fresh ? nullptr : &flags, next);flags.swap(next);fine = &cm.uvs;}@@ -1023,6 +1176,7 @@ void spreadShape(MultiresStack& s, int c, const Mesh& w, const Mesh& r) {// Per level: the subdivided coarse base and its normals (the layer details' frames), once the base channel// (channel 0, done first) is final.std::vector<std::vector<glm::vec3>> frameQ(size_t(c) + 1), frameN(size_t(c) + 1);+ std::vector<std::vector<uint32_t>> frameRef(size_t(c) + 1);bool baseChanged = false;for (size_t ch = 0; ch < channels; ++ch) {const std::vector<glm::vec3>& wa = ch == 0 ? baseChannel(w) : w.layers[ch - 1].delta;@@ -1046,17 +1200,17 @@ void spreadShape(MultiresStack& s, int c, const Mesh& w, const Mesh& r) {parallelRange(tp.coarseVertices, [&](size_t b, size_t e) {for (size_t v = b; v < e; ++v) {const uint32_t e0 = tp.vertEdgeOffsets[v], e1 = tp.vertEdgeOffsets[v + 1];- glm::vec3 sum = delta[tp.vertexChild[v]];+ glm::vec3 sum = delta[tp.vertexChildOf(uint32_t(v))];float weight = 1.0f;for (uint32_t k = e0; k < e1; ++k) {const uint32_t ei = tp.vertEdges[k];- sum += 0.5f * delta[tp.edgeChild[ei]];+ sum += 0.5f * delta[tp.edgeChildOf(ei)];weight += 0.5f;if (!tp.catmullClark) continue;// Each polygon around v borders two of its edges: a quarter weight, half from each.for (uint32_t f : {tp.edgeFaces[ei].x, tp.edgeFaces[ei].y})if (f != kNone) {- sum += 0.125f * delta[tp.faceChild[f]];+ sum += 0.125f * delta[tp.faceChildOf(f)];weight += 0.125f;}}@@ -1068,36 +1222,39 @@ void spreadShape(MultiresStack& s, int c, const Mesh& w, const Mesh& r) {for (size_t v = 0; v < cd.size(); ++v) target[v] += cd[v];delta = std::move(cd);}- // Re-fit the details bottom-up so each level is exactly what it was (the current one exactly as sculpted).+ // The levels up to the current one keep their new positions, which stand for their details (dropped; see+ // SubdivLevel::detail). Sculpt-layer details are kept in the frames of the subdivided base, re-fitted+ // bottom-up so each level is exactly what it was (the current one exactly as sculpted).for (int j = 1; j <= c; ++j) {SubdivLevel& L = s.levels[size_t(j)];+ if (ch == 0) {+ L.detail.reset();+ continue;+ }const SubdivTopology& tp = *L.topo;const Mesh& cm = *s.levels[size_t(j) - 1].data;const Mesh& fm = j == c ? w : *L.data;- const std::vector<glm::vec3>& fineVals = ch == 0 ? baseChannel(fm) : fm.layers[ch - 1].delta;- std::vector<glm::vec3> Q = subdivideField(tp, tp.smooth, ch == 0 ? baseChannel(cm) : cm.layers[ch - 1].delta);- if (ch == 0) {- std::vector<glm::vec3> n = fineNormals(fm.triangles, Q);- fitDetail(tp, n, Q, fineVals, mutableArray(L.detail, Q.size()));- if (channels > 1) { // the layer channels' frames- frameN[size_t(j)] = std::move(n);- frameQ[size_t(j)] = std::move(Q);- }- } else {- if (L.layerDetail.size() < w.layers.size()) L.layerDetail.resize(w.layers.size());- std::vector<glm::vec3>& fq = frameQ[size_t(j)];- if (fq.empty()) {- fq = subdivideField(tp, tp.smooth, baseChannel(cm));- frameN[size_t(j)] = fineNormals(fm.triangles, fq);- }- std::vector<glm::vec3> world(Q.size());- for (size_t v = 0; v < Q.size(); ++v) world[v] = fineVals[v] - Q[v];- layerDetailToLocal(tp, frameN[size_t(j)], fq, world, mutableArray(L.layerDetail[ch - 1], Q.size()));+ const std::vector<glm::vec3>& fineVals = fm.layers[ch - 1].delta;+ std::vector<glm::vec3> Q = subdivideField(tp, tp.smooth, cm.layers[ch - 1].delta);+ if (L.layerDetail.size() < w.layers.size()) L.layerDetail.resize(w.layers.size());+ std::vector<glm::vec3>& fq = frameQ[size_t(j)];+ if (fq.empty()) {+ fq = subdivideField(tp, tp.smooth, baseChannel(cm));+ levelFrames(L, fq, frameN[size_t(j)], frameRef[size_t(j)]);}+ std::vector<glm::vec3> world(Q.size());+ for (size_t v = 0; v < Q.size(); ++v) world[v] = fineVals[v] - Q[v];+ layerDetailToLocal(frameRef[size_t(j)], frameN[size_t(j)], fq, world, mutableArray(L.layerDetail[ch - 1], Q.size()));}}if (!anyChange) return;for (int j = 0; j < c; ++j) evaluateLayers(mutableData(s.levels[size_t(j)]));+ // The levels above follow: each gets the detail that fits its positions on the level below as it was (the+ // current level's old shape is `r`; the ones above haven't changed yet), then waits to be evaluated.+ for (size_t j = size_t(c) + 1; j < s.levels.size(); ++j) {+ SubdivLevel& L = s.levels[j];+ if (!L.stale && !L.detail) fitLevelDetail(L, baseChannel(j == size_t(c) + 1 ? r : *s.levels[j - 1].data));+ }for (size_t j = size_t(c) + 1; j < s.levels.size(); ++j) s.levels[j].stale = true;}@@ -1130,10 +1287,9 @@ void dropStackIfSingle(Mesh& mesh) {if (mesh.multires && mesh.multires->levels.size() < 2) mesh.multires.reset();}-// The fine level of a divide: triangles, quads and every attribute from the coarse level.-std::shared_ptr<Mesh> divideData(SubdivTopology& tp, const Mesh& coarse) {+// The fine level of a divide (generated: no triangles stored): every attribute from the coarse level.+std::shared_ptr<Mesh> divideData(const SubdivTopology& tp, const Mesh& coarse) {auto fine = std::make_shared<Mesh>();- buildDividedFaces(tp, coarse, *fine);std::vector<uint8_t> f;if (coarse.layers.empty()) {fine->positions = subdivideField(tp, tp.smooth, coarse.positions);@@ -1165,10 +1321,10 @@ std::shared_ptr<Mesh> divideData(SubdivTopology& tp, const Mesh& coarse) {} // namespacesize_t SubdivTopology::bytes() const {- auto b = [](const auto& v) { return v.size() * sizeof(v[0]); };+ auto b = [](const auto& v) { return v.capacity() * sizeof(v[0]); };return b(pairing) + b(polyOffsets) + b(polyVerts) + b(polyEdges) + b(polyCorner) + b(polyTris) + b(edges) +b(edgeFaces) + b(vertEdgeOffsets) + b(vertEdges) + b(vertexChild) + b(edgeChild) + b(faceChild) +- b(fineParentPoly) + b(fineParentTri) + b(fineCode) + b(frameRef);+ b(fineParentPoly) + b(fineParentTri) + b(fineCode);}// --- Queries ---@@ -1184,15 +1340,15 @@ std::string subdivLevelText(const Mesh& mesh) {size_t subdivLevelTriangles(const Mesh& mesh, int level) {if (!mesh.multires) return level == 0 ? mesh.triangleCount() : 0;if (level < 0 || level >= int(mesh.multires->levels.size())) return 0;- return mesh.multires->levels[size_t(level)].data->triangleCount();+ return mesh.multires->levels[size_t(level)].triangleCount();}bool subdivMatches(const Mesh& mesh) {if (!mesh.multires) return true;const MultiresStack& s = *mesh.multires;if (s.current < 0 || s.current >= int(s.levels.size()) || !s.levels[size_t(s.current)].data) return false;- const Mesh& r = *s.levels[size_t(s.current)].data;- return r.vertexCount() == mesh.vertexCount() && r.triangleCount() == mesh.triangleCount();+ const SubdivLevel& l = s.levels[size_t(s.current)];+ return l.data->vertexCount() == mesh.vertexCount() && l.triangleCount() == mesh.triangleCount();}size_t subdivBytes(const Mesh& mesh) {@@ -1253,7 +1409,9 @@ bool subdivCommit(Mesh& w) {const int c = w.multires->current;const std::shared_ptr<Mesh> rp = w.multires->levels[size_t(c)].data;const Mesh& r0 = *rp;- if (w.vertexCount() != r0.vertexCount() || !sameArray(w.triangles, r0.triangles)) {+ const SubdivLevel& cl = w.multires->levels[size_t(c)];+ if (w.vertexCount() != r0.vertexCount() ||+ !(generatedLevel(cl) ? matchesGenerated(*cl.topo, w.triangles) : sameArray(w.triangles, r0.triangles))) {w.multires.reset(); // the topology changed under the stack: the levels no longer applyreturn false;}@@ -1322,7 +1480,7 @@ bool subdivCommit(Mesh& w) {spreadFaceArray(s, c, w.hidden, r->hidden, uint8_t(0), [](Mesh& m) -> std::vector<uint8_t>& { return m.hidden; });spreadUvs(s, c, w, *r);- s.levels[size_t(c)].data = leanShared(w);+ s.levels[size_t(c)].data = levelData(w, s.levels[size_t(c)]);return true;}@@ -1344,9 +1502,9 @@ bool subdivSetLevel(Mesh& mesh, int level, std::string& error, BVH* bvh) {MultiresStack& s = mutableStack(mesh);for (int k = s.current + 1; k <= level; ++k)if (s.levels[size_t(k)].stale) evaluateLevel(s, k);- std::shared_ptr<Mesh> leaving = s.levels[size_t(s.current)].data;+ const SubdivLevel leaving = s.levels[size_t(s.current)];s.current = level;- enterLevel(mesh, level, bvh, std::move(leaving));+ enterLevel(mesh, level, bvh, &leaving);return true;}@@ -1374,21 +1532,23 @@ bool subdivDivide(Mesh& mesh, bool smooth, std::string& error, BVH* bvh, size_treturn false;}MultiresStack& s = ensureStack(mesh);- std::shared_ptr<Mesh> leaving = s.levels.back().data;- const Mesh& coarse = *leaving;+ const SubdivLevel leaving = s.levels.back();+ // The coarse level is the top one, which the working mesh is (with its edits folded in above).+ const Mesh& coarse = mesh;std::vector<uint32_t> pairing;if (cc) {pairing.resize(coarse.triangleCount());for (uint32_t t = 0; t < pairing.size(); ++t) pairing[t] = coarse.quadPartnerAt(t);}- std::shared_ptr<SubdivTopology> tp = buildCoarse(coarse, std::move(pairing), cc, smooth);+ std::shared_ptr<SubdivTopology> tp = buildCoarse(coarse.triangles, uint32_t(coarse.vertexCount()), std::move(pairing), cc, smooth);+ tp->generated = true;SubdivLevel level;level.data = divideData(*tp, coarse);level.topo = tp;level.layerDetail.resize(coarse.layers.size());s.levels.push_back(std::move(level));s.current = int(s.levels.size()) - 1;- enterLevel(mesh, s.current, bvh, std::move(leaving));+ enterLevel(mesh, s.current, bvh, &leaving);return true;}@@ -1402,6 +1562,11 @@ bool subdivDeleteLower(Mesh& mesh, std::string& error) {return false;}MultiresStack& s = mutableStack(mesh);+ if (generatedLevel(s.levels[size_t(s.current)])) { // the new base keeps its triangles itself+ Mesh& base = mutableData(s.levels[size_t(s.current)]);+ base.triangles = mesh.triangles;+ base.quadPartners = mesh.quadPartners;+ }s.levels.erase(s.levels.begin(), s.levels.begin() + s.current);s.current = 0;s.levels[0].topo.reset();@@ -1445,20 +1610,30 @@ Mesh subdivLevelMesh(const Mesh& mesh, int level) {// --- Project files ----std::shared_ptr<const SubdivTopology> rebuildSubdivTopology(const Mesh& coarse, const Mesh& fine,+std::shared_ptr<const SubdivTopology> rebuildSubdivTopology(const std::vector<glm::uvec3>& coarseTriangles,+ uint32_t coarseVertices, uint32_t fineVertices,+ const std::vector<glm::uvec3>* fineTriangles,std::vector<uint32_t> pairing, bool catmullClark,bool smooth, std::vector<uint32_t> vertexChild,std::vector<uint32_t> edgeChild,std::vector<uint32_t> faceChild, std::string& error) {- std::shared_ptr<SubdivTopology> tp = buildCoarse(coarse, std::move(pairing), catmullClark, smooth);+ std::shared_ptr<SubdivTopology> tp = buildCoarse(coarseTriangles, coarseVertices, std::move(pairing), catmullClark, smooth);+ if (tp->fineVertices != fineVertices) {+ error = "subdivision level vertex counts don't match";+ return nullptr;+ }+ if (!fineTriangles) {+ tp->generated = true;+ return tp;+ }tp->vertexChild = std::move(vertexChild);tp->edgeChild = std::move(edgeChild);tp->faceChild = std::move(faceChild);- if (tp->fineVertices != fine.vertexCount()) {- error = "subdivision level vertex counts don't match";- return nullptr;+ if (canonicalChildren(*tp) && matchesGenerated(*tp, *fineTriangles)) {+ markGenerated(*tp);+ return tp;}- if (!buildFineMetadata(*tp, coarse, fine.triangles, error)) return nullptr;+ if (!buildFineMetadata(*tp, *fineTriangles, error)) return nullptr;return tp;}@@ -1469,9 +1644,17 @@ bool attachSubdivStack(Mesh& mesh, MultiresStack stack, std::string& error) {return false;}for (size_t j = 0; j < n; ++j) {- const SubdivLevel& l = stack.levels[j];+ SubdivLevel& l = stack.levels[j];+ if (l.data && generatedLevel(l) && !l.data->triangles.empty()) { // they follow from the topology+ if (l.data.use_count() > 1) l.data = std::make_shared<Mesh>(*l.data);+ std::vector<glm::uvec3>().swap(l.data->triangles);+ bool generatedPairs = l.topo->catmullClark && l.data->quadPartners.size() == l.topo->fineTriangles;+ for (size_t t = 0; t < l.data->quadPartners.size() && generatedPairs; ++t)+ generatedPairs = l.data->quadPartners[t] == uint32_t(t ^ 1);+ if (generatedPairs) std::vector<uint32_t>().swap(l.data->quadPartners);+ }if (!l.data || (j > 0 && (!l.topo || l.topo->fineVertices != l.data->vertexCount() ||- l.topo->fineParentTri.size() != l.data->triangleCount())) ||+ (!l.topo->generated && l.topo->fineTriangles != l.data->triangleCount()))) ||(l.detail && l.detail->size() != l.data->vertexCount())) {error = "subdivision level " + std::to_string(j + 1) + " doesn't fit the level below";return false;@@ -1486,8 +1669,9 @@ bool attachSubdivStack(Mesh& mesh, MultiresStack stack, std::string& error) {return false;}}- const Mesh& cur = *stack.levels[size_t(stack.current)].data;- if (cur.vertexCount() != mesh.vertexCount() || cur.triangles != mesh.triangles) {+ const SubdivLevel& cl = stack.levels[size_t(stack.current)];+ if (cl.data->vertexCount() != mesh.vertexCount() ||+ !(generatedLevel(cl) ? matchesGenerated(*cl.topo, mesh.triangles) : cl.data->triangles == mesh.triangles)) {error = "the current subdivision level doesn't match the mesh";return false;}@@ -1507,11 +1691,13 @@ void convertWorldLayerDetail(MultiresStack& s) {if (k >= 2 && s.levels[k - 1].stale) evaluateLevel(s, int(k) - 1);const SubdivTopology& tp = *L.topo;const std::vector<glm::vec3> Q = subdivideField(tp, tp.smooth, baseChannel(*s.levels[k - 1].data));- const std::vector<glm::vec3> n = fineNormals(L.data->triangles, Q);+ std::vector<glm::vec3> n;+ std::vector<uint32_t> refs;+ levelFrames(L, Q, n, refs);for (auto& d : L.layerDetail) {if (!d || d->size() != Q.size()) continue;auto local = std::make_shared<std::vector<glm::vec3>>();- layerDetailToLocal(tp, n, Q, *d, *local);+ layerDetailToLocal(refs, n, Q, *d, *local);d = std::move(local);}}@@ -1519,10 +1705,20 @@ void convertWorldLayerDetail(MultiresStack& s) {const Mesh& subdivLevelData(const Mesh& mesh, int level) { return *mesh.multires->levels[size_t(level)].data; }+const SubdivLevel& subdivLevel(const Mesh& mesh, int level) { return mesh.multires->levels[size_t(level)]; }++void subdivLevelFaces(const Mesh& mesh, int level, std::vector<glm::uvec3>& out) {+ const SubdivLevel& l = mesh.multires->levels[size_t(level)];+ if (generatedLevel(l)) generateFaces(*l.topo, out, nullptr);+ else out = l.data->triangles;+}+bool subdivInSync(const Mesh& mesh) {if (!mesh.multires) return true;- const Mesh& r = *mesh.multires->levels[size_t(mesh.multires->current)].data;- return sameArray(mesh.triangles, r.triangles) && !levelsDiffer(mesh, r);+ const SubdivLevel& l = mesh.multires->levels[size_t(mesh.multires->current)];+ const Mesh& r = *l.data;+ return (generatedLevel(l) ? matchesGenerated(*l.topo, mesh.triangles) : sameArray(mesh.triangles, r.triangles)) &&+ !levelsDiffer(mesh, r);}// --- Reconstruct Subdiv ---@@ -1551,7 +1747,7 @@ bool reconstructCatmullClark(const Mesh& m, Reconstruction& out, std::string& erreturn false;}}- const std::shared_ptr<SubdivTopology> w = buildCoarse(m, pairing, true, true);+ const std::shared_ptr<SubdivTopology> w = buildCoarse(m.triangles, uint32_t(m.vertexCount()), pairing, true, true);const size_t np = w->polygonCount();for (size_t p = 0; p < np; ++p)if (polySize(*w, p) != 4) {@@ -1708,7 +1904,7 @@ bool reconstructCatmullClark(const Mesh& m, Reconstruction& out, std::string& er// All-triangle mesh: label vertices O / E so every triangle is a corner (O, E, E) or a centre (E, E, E) one.bool reconstructLoop(const Mesh& m, Reconstruction& out, std::string& error) {- const std::shared_ptr<SubdivTopology> w = buildCoarse(m, {}, false, true);+ const std::shared_ptr<SubdivTopology> w = buildCoarse(m.triangles, uint32_t(m.vertexCount()), {}, false, true);const uint32_t nv = uint32_t(m.vertexCount()), nt = uint32_t(m.triangleCount());std::vector<uint8_t> label(nv, kUnset), type(nt, 0), done(nt, 0); // type 1 = corner, 2 = centrefor (uint32_t seed = 0; seed < nt; ++seed) {@@ -1855,7 +2051,7 @@ bool subdivReconstruct(Mesh& mesh, std::string& error, BVH* bvh) {Mesh& coarse = rec.coarse;coarse.positions.resize(nc);for (uint32_t v = 0; v < nc; ++v) coarse.positions[v] = mesh.positions[rec.vertexChild[v]];- std::shared_ptr<SubdivTopology> tp = buildCoarse(coarse, rec.pairing, rec.catmullClark, true);+ std::shared_ptr<SubdivTopology> tp = buildCoarse(coarse.triangles, nc, rec.pairing, rec.catmullClark, true);tp->vertexChild = rec.vertexChild;tp->faceChild = rec.catmullClark ? rec.faceChild : std::vector<uint32_t>{};tp->edgeChild.resize(tp->edges.size());@@ -1871,7 +2067,7 @@ bool subdivReconstruct(Mesh& mesh, std::string& error, BVH* bvh) {error = "The mesh is not a regular subdivision (vertex counts don't add up)";return false;}- if (!buildFineMetadata(*tp, coarse, mesh.triangles, error)) return false;+ if (!buildFineMetadata(*tp, mesh.triangles, error)) return false;// Expected fine triangle count: 2n per n-gon (Catmull-Clark) or 4 per triangle (Loop).size_t expected = 0;for (size_t p = 0; p < tp->polygonCount(); ++p) expected += tp->catmullClark ? 2 * polySize(*tp, p) : 4;@@ -1891,7 +2087,7 @@ bool subdivReconstruct(Mesh& mesh, std::string& error, BVH* bvh) {if (mesh.hasColors()) restrictVertices(*tp, mesh.colors, coarse.colors, glm::vec3(1.0f), nullptr, f);if (mesh.hasPolygroups()) restrictFaces(*tp, mesh.polygroups, coarse.polygroups, coarse.triangleCount(), 0u, nullptr, f);if (mesh.hasHidden()) restrictFaces(*tp, mesh.hidden, coarse.hidden, coarse.triangleCount(), uint8_t(0), nullptr, f);- if (mesh.hasUvs()) restrictUvs(*tp, coarse, mesh.uvs, coarse.uvs, nullptr, f);+ if (mesh.hasUvs()) restrictUvs(*tp, coarse.triangles, mesh.uvs, coarse.uvs, nullptr, f);if (!rec.pairing.empty()) coarse.quadPartners = rec.pairing;if (!mesh.paintLayers.empty()) {restrictVertices(*tp, mesh.paintBase, coarse.paintBase, glm::vec3(1.0f), nullptr, f);@@ -1908,11 +2104,12 @@ bool subdivReconstruct(Mesh& mesh, std::string& error, BVH* bvh) {}SubdivLevel fineLevel;fineLevel.topo = tp;- // The coarse base is the positions so far (the layers' offsets are added below).- const std::vector<glm::vec3> Q = subdivideField(*tp, true, coarse.positions);if (!mesh.layers.empty()) {+ // The coarse base is the positions so far (the layers' offsets are added below).+ const std::vector<glm::vec3> Q = subdivideField(*tp, true, coarse.positions);coarse.base = coarse.positions;const std::vector<glm::vec3> n = fineNormals(mesh.triangles, Q);+ const std::vector<uint32_t> refs = frameRefs(tp->fineVertices, mesh.triangles);for (const SculptLayer& l : mesh.layers) {SculptLayer cl{l.name, std::vector<glm::vec3>(nc), l.weight};for (uint32_t v = 0; v < nc; ++v) cl.delta[v] = l.delta[rec.vertexChild[v]];@@ -1920,21 +2117,20 @@ bool subdivReconstruct(Mesh& mesh, std::string& error, BVH* bvh) {std::vector<glm::vec3> world(s.size());for (size_t v = 0; v < s.size(); ++v) world[v] = l.delta[v] - s[v];auto d = std::make_shared<std::vector<glm::vec3>>();- layerDetailToLocal(*tp, n, Q, world, *d);+ layerDetailToLocal(refs, n, Q, world, *d);fineLevel.layerDetail.push_back(std::move(d));coarse.layers.push_back(std::move(cl));}evaluateLayers(coarse);}- fineLevel.detail = std::make_shared<std::vector<glm::vec3>>();- fitDetail(*tp, fineNormals(mesh.triangles, Q), Q, fineBase, *fineLevel.detail);+ // The fine level's detail is what fits its positions (fitted when the coarse level changes; SubdivLevel::detail).MultiresStack& s = ensureStack(mesh);fineLevel.data = s.levels[0].data;fineLevel.stale = false;s.levels[0] = std::move(fineLevel);s.levels.insert(s.levels.begin(), SubdivLevel{std::make_shared<Mesh>(std::move(coarse)), nullptr, nullptr, {}, false});s.current = 0;- enterLevel(mesh, 0, bvh, s.levels[1].data);+ enterLevel(mesh, 0, bvh, &s.levels[1]);return true;}@@ -1953,12 +2149,12 @@ size_t SubdivUndo::bytes() const {void applySubdivUndo(SubdivUndo& r, Mesh& mesh, BVH& bvh) {subdivCommit(mesh);- std::shared_ptr<Mesh> leaving = mesh.multires ? mesh.multires->levels[size_t(mesh.multires->current)].data : nullptr;+ const SubdivLevel leaving = mesh.multires ? mesh.multires->levels[size_t(mesh.multires->current)] : SubdivLevel{};std::shared_ptr<SubdivLevelCache> cache = mesh.multires ? mesh.multires->cache : nullptr;std::swap(mesh.multires, r.stack);if (mesh.multires) {if (!mesh.multires->cache) mesh.multires->cache = std::move(cache);- enterLevel(mesh, mesh.multires->current, &bvh, std::move(leaving));+ enterLevel(mesh, mesh.multires->current, &bvh, &leaving);return;} else if (r.plain) {std::shared_ptr<PaintTexture> texture = mesh.texture;diff --git a/src/core/Multires.h b/src/core/Multires.hindex a01e8f89..abe75d27 100644--- a/src/core/Multires.h+++ b/src/core/Multires.h@@ -52,10 +52,18 @@ struct Document;// How level k is built from level k-1. Vertex, edge and face points of the coarse level map to fine vertices// through vertexChild / edgeChild / faceChild, so a reconstructed level keeps the vertex order it was found in.+//+// A level made by Divide (or loaded / checked to be one) is `generated`: its fine vertices are the coarse+// vertices, then one per coarse edge, then one per polygon (Catmull-Clark), and its fine triangles and quad+// pairs are the ones generateFaces() makes, polygon by polygon. Such a level stores neither the child maps,+// nor its triangles (in SubdivLevel::data), nor their parents and corner codes: all of them follow from the+// coarse polygons, which saves about 30 bytes per triangle at the top level.struct SubdivTopology {bool catmullClark = false; // quads (and triangles) -> quads; false = Loop, triangles -> 4 trianglesbool smooth = true; // false: flat subdivision (Smt off), the shape is not smoothed+ bool generated = false;uint32_t coarseVertices = 0, fineVertices = 0;+ size_t fineTriangles = 0;// The quad pairing of the coarse level's triangles this level was built with (Mesh::kNoQuad = triangle).std::vector<uint32_t> pairing;// Coarse polygons (triangles and quads), corners in winding order (CSR).@@ -66,29 +74,45 @@ struct SubdivTopology {// Coarse edges (a < b) and the polygons on each side; y = kNone on boundaries and non-manifold edges.std::vector<glm::uvec2> edges, edgeFaces;std::vector<uint32_t> vertEdgeOffsets, vertEdges; // coarse vertex -> incident edges (CSR)- std::vector<uint32_t> vertexChild, edgeChild, faceChild; // fine vertex of each coarse vertex / edge / polygon- // Per fine triangle: the polygon and the coarse triangle it lies in, and per fine corner where it sits on- // that polygon (0-3 = corner i, 4-7 = midpoint of side i, 8 = centre), for UVs.+ // Not generated only: the fine vertex of each coarse vertex / edge / polygon, and per fine triangle the+ // polygon and the coarse triangle it lies in, and per fine corner where it sits on that polygon (0-3 =+ // corner i, 4-7 = midpoint of side i, 8 = centre), for UVs.+ std::vector<uint32_t> vertexChild, edgeChild, faceChild;std::vector<uint32_t> fineParentPoly, fineParentTri;std::vector<uint8_t> fineCode;- std::vector<uint32_t> frameRef; // per fine vertex: the neighbour that fixes its tangent direction+ bool nonManifold = false; // some coarse edge has more than two polygons+ uint32_t maxValence = 0; // most edges at one coarse vertexstatic constexpr uint32_t kNone = ~0u;size_t polygonCount() const { return polyOffsets.empty() ? 0 : polyOffsets.size() - 1; }+ uint32_t vertexChildOf(uint32_t v) const { return generated ? v : vertexChild[v]; }+ uint32_t edgeChildOf(uint32_t e) const { return generated ? coarseVertices + e : edgeChild[e]; }+ uint32_t faceChildOf(uint32_t p) const { return generated ? coarseVertices + uint32_t(edges.size()) + p : faceChild[p]; }+ // The first fine triangle of polygon p (generated levels: 2 per corner for Catmull-Clark, 4 for Loop).+ size_t firstFineTriangle(size_t p) const { return catmullClark ? size_t(polyOffsets[p]) * 2 : p * 4; }size_t bytes() const;};-// One level of the stack. `data` is the level as a mesh without topology (positions, triangles, every-// attribute, sculpt and paint layers; no texture). For levels above the one last edited `stale` is set and-// data->positions / base / layer deltas are out of date until the level is evaluated again.+// The fine triangles of a generated level, in order, and (Catmull-Clark) their quad pairs (each corner of a+// polygon becomes one quad: triangles 2i and 2i + 1).+void generateFaces(const SubdivTopology& tp, std::vector<glm::uvec3>& triangles, std::vector<uint32_t>* quadPartners);++// One level of the stack. `data` is the level as a mesh without topology (positions, every attribute, sculpt+// and paint layers; no texture; the triangles and quad pairs only when the level isn't generated, see+// SubdivTopology). For levels above the one last edited `stale` is set and data->positions / base / layer+// deltas are out of date until the level is evaluated again.struct SubdivLevel {std::shared_ptr<Mesh> data;std::shared_ptr<const SubdivTopology> topo; // null for level 0- std::shared_ptr<std::vector<glm::vec3>> detail; // local-frame displacement (levels >= 1)+ // Local-frame displacement (levels >= 1). Null on a level that isn't stale: its positions are what counts+ // and its detail is fitted to them when it is needed (when a lower level changes), so the stack doesn't+ // keep both. Null on a stale level: no detail (the level is the smooth subdivision of the one below).+ std::shared_ptr<std::vector<glm::vec3>> detail;// Per sculpt layer: its offsets minus the subdivided offsets of the level below, in the local frame of the// subdivided shape (as `detail`), so they turn with the surface.std::vector<std::shared_ptr<std::vector<glm::vec3>>> layerDetail;bool stale = false;+ size_t triangleCount() const { return topo && topo->generated ? topo->fineTriangles : data->triangleCount(); }};// Working meshes (with topology and normals) and BVHs of the levels most recently left, so stepping back to@@ -154,9 +178,14 @@ bool subdivCommit(Mesh& mesh);Mesh subdivLevelMesh(const Mesh& mesh, int level);// --- Project files ----// Rebuilds the topology of a saved level (`fine`, built from `coarse`) from what the file keeps: the scheme,-// Smt, the quad pairing and the child maps. Null with `error` set when they don't fit the meshes.-std::shared_ptr<const SubdivTopology> rebuildSubdivTopology(const Mesh& coarse, const Mesh& fine,+// Rebuilds the topology of a saved level from what the file keeps: the coarse level's triangles and vertex+// count, the fine vertex count, the scheme, Smt, the quad pairing and the child maps. `fineTriangles` are the+// level's own triangles, or null for a generated level (which stores none). A level whose child maps and+// triangles are the generated ones becomes generated (attachSubdivStack then drops its triangles). Null with+// `error` set when they don't fit the meshes.+std::shared_ptr<const SubdivTopology> rebuildSubdivTopology(const std::vector<glm::uvec3>& coarseTriangles,+ uint32_t coarseVertices, uint32_t fineVertices,+ const std::vector<glm::uvec3>* fineTriangles,std::vector<uint32_t> pairing, bool catmullClark,bool smooth, std::vector<uint32_t> vertexChild,std::vector<uint32_t> edgeChild,@@ -166,8 +195,11 @@ bool attachSubdivStack(Mesh& mesh, MultiresStack stack, std::string& error);// Projects before format 5 stored sculpt-layer details in world space: converts a loaded stack's (with its// topology) to the local frames SubdivLevel::layerDetail uses now. Evaluates stale levels on the way.void convertWorldLayerDetail(MultiresStack& stack);-// The level data `level` keeps (for writing projects; may be stale, see SubdivLevel).+// The level data `level` keeps (for writing projects; may be stale, see SubdivLevel), and the level itself.const Mesh& subdivLevelData(const Mesh& mesh, int level);+const SubdivLevel& subdivLevel(const Mesh& mesh, int level);+// The triangles of level `level` (stored or generated).+void subdivLevelFaces(const Mesh& mesh, int level, std::vector<glm::uvec3>& out);// True when the mesh holds no edits its stack hasn't folded in yet (its current level's data is the mesh).bool subdivInSync(const Mesh& mesh);diff --git a/src/core/Project.cpp b/src/core/Project.cppindex a2bbf3ce..63e8c12b 100644--- a/src/core/Project.cpp+++ b/src/core/Project.cpp@@ -170,14 +170,19 @@ size_t countOf(const Json& j) {}-// Writes a mesh's blobs under `prefix` ("subtools/0/") and sets `mesh` and `layers` in `out`.-void writeMesh(Writer& w, const std::string& prefix, const Mesh& m, Json& out) {+// Writes a mesh's blobs under `prefix` ("subtools/0/") and sets `mesh` and `layers` in `out`. `generatedTriangles`:+// a generated subdivision level's triangle count; its triangles aren't written (format 6).+void writeMesh(Writer& w, const std::string& prefix, const Mesh& m, Json& out, size_t generatedTriangles = 0) {Json mesh = Json::object();mesh.set("vertex_count", double(m.vertexCount()));- mesh.set("triangle_count", double(m.triangleCount()));mesh.set("positions", w.vec3s(prefix + "mesh/positions.bin", m.positions));- mesh.set("triangles", w.uints(prefix + "mesh/triangles.bin", m.triangles.empty() ? nullptr : &m.triangles[0].x,- m.triangleCount(), 3));+ if (generatedTriangles) {+ mesh.set("triangle_count", double(generatedTriangles));+ } else {+ mesh.set("triangle_count", double(m.triangleCount()));+ mesh.set("triangles", w.uints(prefix + "mesh/triangles.bin", m.triangles.empty() ? nullptr : &m.triangles[0].x,+ m.triangleCount(), 3));+ }if (!m.layers.empty()) mesh.set("base", w.vec3s(prefix + "mesh/base.bin", m.base));if (m.hasMask()) mesh.set("mask", w.floats(prefix + "mesh/mask.bin", m.mask.data(), m.mask.size(), 1));if (m.hasColors()) mesh.set("colors", w.vec3s(prefix + "mesh/colors.bin", m.colors));@@ -201,16 +206,18 @@ void writeMesh(Writer& w, const std::string& prefix, const Mesh& m, Json& out) {out.set("layers", std::move(layers));}-// Reads a mesh from its `mesh` and `layers` manifest entries (size-checked against the blobs).-bool readMesh(Reader& r, const Json& mj, const Json& lj, Mesh& m, std::string& error) {+// Reads a mesh from its `mesh` and `layers` manifest entries (size-checked against the blobs). `levelData`: a+// subdivision level's arrays, kept without topology or normals; a generated level's have no triangles.+bool readMesh(Reader& r, const Json& mj, const Json& lj, Mesh& m, std::string& error, bool levelData = false) {const size_t nv = countOf(mj["vertex_count"]), nt = countOf(mj["triangle_count"]);if (nv == size_t(-1) || nt == size_t(-1)) {error = "Project mesh has no valid vertex/triangle count";return false;}- m.triangles.resize(nt);+ const bool withTriangles = !levelData || mj.has("triangles");+ if (withTriangles) m.triangles.resize(nt);if (!r.vec3s(mj["positions"], "positions", nv, m.positions) ||- !r.uints(mj["triangles"], "triangles", nt, 3, nt ? &m.triangles[0].x : nullptr)) {+ (withTriangles && !r.uints(mj["triangles"], "triangles", nt, 3, nt ? &m.triangles[0].x : nullptr))) {error = r.error;return false;}@@ -253,6 +260,10 @@ bool readMesh(Reader& r, const Json& mj, const Json& lj, Mesh& m, std::string& eerror = r.error;return false;}+ if (levelData) {+ if (!m.layers.empty()) m.evaluateAll();+ return true;+ }m.rebuildTopology();if (!m.layers.empty()) m.evaluateAll();m.recomputeAllNormals();@@ -408,21 +419,26 @@ bool readTexture(Reader& r, const Json& tj, Mesh& m, std::string& error) {// Subdivision levels (core/Multires.h) are the SubTool key "subdiv" (format 4; sculpt-layer details in local// frames from format 5): the current level and every level's mesh (as "mesh" / "layers" / "paint_layers"),-// details and topology (scheme, Smt, quad pairing and child maps). The SubTool's own "mesh" is the current level, so readers that don't know levels load what was shown.-// A current level identical to that mesh is not written twice ("same_as_mesh").+// details and topology (scheme, Smt, quad pairing and child maps). The SubTool's own "mesh" is the current level,+// so readers that don't know levels load what was shown. A current level identical to that mesh is not written+// twice ("same_as_mesh"). Format 6: a generated level (made by Divide, SubdivTopology::generated) has no+// triangles and no child maps ("generated"), and a level without "detail" that isn't stale takes the detail that+// fits its positions (SubdivLevel::detail).Json writeSubdiv(Writer& w, const std::string& prefix, const Mesh& m) {Json out = Json::object();out.set("current", subdivCurrentLevel(m));Json levels = Json::array();+ const bool inSync = subdivInSync(m);for (int i = 0; i < subdivLevelCount(m); ++i) {const std::string p = prefix + "subdiv/" + std::to_string(i) + "/";- const SubdivLevel& l = m.multires->levels[size_t(i)];+ const SubdivLevel& l = subdivLevel(m, i);const Mesh& data = *l.data;+ const bool generated = l.topo && l.topo->generated;Json lj = Json::object();- if (i == subdivCurrentLevel(m) && subdivInSync(m)) {+ if (i == subdivCurrentLevel(m) && inSync) {lj.set("same_as_mesh", true);} else {- writeMesh(w, p, data, lj);+ writeMesh(w, p, data, lj, generated ? l.triangleCount() : 0);if (hasPaintLayers(data)) lj.set("paint_layers", writePaintLayers(w, p, data));}if (l.stale) lj.set("stale", true);@@ -432,9 +448,13 @@ Json writeSubdiv(Writer& w, const std::string& prefix, const Mesh& m) {t.set("catmull_clark", tp.catmullClark);t.set("smooth", tp.smooth);if (!tp.pairing.empty()) t.set("pairing", w.uints(p + "pairing.bin", tp.pairing.data(), tp.pairing.size(), 1));- t.set("vertex_child", w.uints(p + "vertex_child.bin", tp.vertexChild.data(), tp.vertexChild.size(), 1));- t.set("edge_child", w.uints(p + "edge_child.bin", tp.edgeChild.data(), tp.edgeChild.size(), 1));- if (!tp.faceChild.empty()) t.set("face_child", w.uints(p + "face_child.bin", tp.faceChild.data(), tp.faceChild.size(), 1));+ if (generated) {+ t.set("generated", true);+ } else {+ t.set("vertex_child", w.uints(p + "vertex_child.bin", tp.vertexChild.data(), tp.vertexChild.size(), 1));+ t.set("edge_child", w.uints(p + "edge_child.bin", tp.edgeChild.data(), tp.edgeChild.size(), 1));+ if (!tp.faceChild.empty()) t.set("face_child", w.uints(p + "face_child.bin", tp.faceChild.data(), tp.faceChild.size(), 1));+ }lj.set("topology", std::move(t));}if (l.detail) lj.set("detail", w.vec3s(p + "detail.bin", *l.detail));@@ -474,32 +494,38 @@ bool readSubdiv(Reader& r, const Json& sj, Mesh& m, std::string& error, bool worreturn false;}stack.current = int(current);+ // The triangles of the level below (its own, or generated into one of the two buffers), to build each level's+ // topology from.+ const std::vector<glm::uvec3>* below = nullptr;+ std::vector<glm::uvec3> generatedBelow[2];for (size_t i = 0; i < list.size(); ++i) {const Json& lj = list[i];+ const bool generated = i > 0 && lj["topology"]["generated"].asBool(false);SubdivLevel level;auto data = std::make_shared<Mesh>();if (lj["same_as_mesh"].asBool(false) && i == size_t(stack.current)) {- *data = m;+ // Just the level's arrays (no topology, normals or texture), as the stack stores levels.+ if (!generated) data->triangles = m.triangles;+ data->positions = m.positions;+ data->mask = m.mask;+ data->colors = m.colors;+ data->polygroups = m.polygroups;+ data->hidden = m.hidden;+ data->uvs = m.uvs;+ data->quadPartners = m.quadPartners;+ data->base = m.base;+ data->layers = m.layers;+ data->paintBase = m.paintBase;+ data->paintLayers = m.paintLayers;+ data->activePaintLayer = m.activePaintLayer;} else {- if (!readMesh(r, lj["mesh"], lj["layers"], *data, error)) return false;+ if (!readMesh(r, lj["mesh"], lj["layers"], *data, error, true)) return false;if (!readPaintLayers(r, lj["paint_layers"], *data, error)) return false;+ if (data->triangles.empty() && !generated && countOf(lj["mesh"]["triangle_count"]) != 0) {+ error = "Project subdivision level " + std::to_string(i + 1) + " has no triangles";+ return false;+ }}- // Keep just the level's arrays (no topology, normals or texture), as the stack stores levels.- Mesh lean;- lean.positions = std::move(data->positions);- lean.triangles = std::move(data->triangles);- lean.mask = std::move(data->mask);- lean.colors = std::move(data->colors);- lean.polygroups = std::move(data->polygroups);- lean.hidden = std::move(data->hidden);- lean.uvs = std::move(data->uvs);- lean.quadPartners = std::move(data->quadPartners);- lean.base = std::move(data->base);- lean.layers = std::move(data->layers);- lean.paintBase = std::move(data->paintBase);- lean.paintLayers = std::move(data->paintLayers);- lean.activePaintLayer = data->activePaintLayer;- *data = std::move(lean);level.data = std::move(data);level.stale = lj["stale"].asBool(false);const size_t nv = level.data->vertexCount();@@ -526,19 +552,32 @@ bool readSubdiv(Reader& r, const Json& sj, Mesh& m, std::string& error, bool worconst Json& t = lj["topology"];std::vector<uint32_t> pairing, vc, ec, fc;if ((t.has("pairing") && !readUintList(r, t["pairing"], "subdivision quad pairing", pairing)) ||- !readUintList(r, t["vertex_child"], "subdivision vertex map", vc) ||- !readUintList(r, t["edge_child"], "subdivision edge map", ec) ||- (t.has("face_child") && !readUintList(r, t["face_child"], "subdivision face map", fc))) {+ (!generated && (!readUintList(r, t["vertex_child"], "subdivision vertex map", vc) ||+ !readUintList(r, t["edge_child"], "subdivision edge map", ec) ||+ (t.has("face_child") && !readUintList(r, t["face_child"], "subdivision face map", fc))))) {error = r.error;return false;}- level.topo = rebuildSubdivTopology(*stack.levels[i - 1].data, *level.data, std::move(pairing),+ level.topo = rebuildSubdivTopology(*below, uint32_t(stack.levels[i - 1].data->vertexCount()), uint32_t(nv),+ generated ? nullptr : &level.data->triangles, std::move(pairing),t["catmull_clark"].asBool(false), t["smooth"].asBool(true),std::move(vc), std::move(ec), std::move(fc), error);if (!level.topo) {error = "Project " + error;return false;}+ if (generated && level.topo->fineTriangles != countOf(lj["mesh"]["triangle_count"]) && !lj["same_as_mesh"].asBool(false)) {+ error = "Project subdivision level " + std::to_string(i + 1) + " doesn't fit the level below";+ return false;+ }+ }+ if (i + 1 < list.size()) { // the next level is built on this one's triangles+ if (level.topo && level.topo->generated && level.data->triangles.empty()) {+ generateFaces(*level.topo, generatedBelow[i % 2], nullptr);+ below = &generatedBelow[i % 2];+ } else {+ below = &level.data->triangles;+ }}stack.levels.push_back(std::move(level));}diff --git a/src/core/Project.h b/src/core/Project.hindex 9b0ad807..4ad2eae5 100644--- a/src/core/Project.h+++ b/src/core/Project.h@@ -23,8 +23,9 @@ namespace sf {// 1: one mesh. 2: a list of SubTools (version 1 files still load, as one SubTool). 3: SubTools may carry a// painted texture with layers ("texture"; older files still load). 4: SubTools may carry subdivision levels// ("subdiv"; older files still load). 5: sculpt-layer details of subdivision levels are in the levels' local-// frames, not world space (format 4 files are converted when they load).-constexpr int kProjectVersion = 5;+// frames, not world space (format 4 files are converted when they load). 6: levels made by Divide keep no+// triangles, child maps or (where their positions say it) details; older files still load.+constexpr int kProjectVersion = 6;constexpr const char* kProjectExtension = ".sfproj";// True for paths ending in .sfproj (any case).