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
// SculptForge - open source digital sculpting
// SPDX-License-Identifier: GPL-3.0-or-later
//
// Garments (core/Garment.h): pattern panels, even triangulation, seams that weld into one consistently oriented
// garment (a T-shirt sewn from its template is a single surface with exactly four openings: hem, neck, two
// sleeves), the flat rest shape, project and file round trips (SVG, DXF), the SVG reader against
// hostile input, and the garment_* commands.
#include "TestHarness.h"
#include "core/Commands.h"
#include "core/Garment.h"
#include "core/Primitives.h"
#include "core/Project.h"
#include <algorithm>
#include <chrono>
#include <cmath>
#include <fstream>
#include <map>
#include <random>
#include <set>
#include <sstream>
using namespace sf;
using namespace sf::garment;
namespace {
float meshArea(const GarmentMesh& m, uint32_t panel) {
double a = 0.0;
for (uint32_t t = m.panelFirstTriangle[panel]; t < m.panelFirstTriangle[panel + 1]; ++t) {
const glm::uvec3 tri = m.triangles[t];
const glm::vec2 u = m.flat[tri.y] - m.flat[tri.x], v = m.flat[tri.z] - m.flat[tri.x];
a += 0.5 * double(u.x * v.y - u.y * v.x);
}
return float(a);
}
// Boundary loops and orientation of a closed-up mesh: every edge used once (border) or twice in opposite
// directions (consistently oriented); edges used twice the same way or more than twice break it.
struct Topology {
int borderLoops = 0;
bool consistent = true;
bool manifold = true;
};
Topology topology(const Mesh& m) {
std::map<std::pair<uint32_t, uint32_t>, int> directed;
for (const glm::uvec3& t : m.triangles)
for (int k = 0; k < 3; ++k) ++directed[{t[k], t[(k + 1) % 3]}];
Topology r;
std::map<uint32_t, uint32_t> next; // border: a -> b
for (const auto& [e, n] : directed) {
if (n > 1) r.consistent = false;
const auto back = directed.find({e.second, e.first});
const int other = back == directed.end() ? 0 : back->second;
if (n + other > 2) r.manifold = false;
if (other == 0) {
if (next.count(e.first)) r.manifold = false;
next[e.first] = e.second;
}
}
std::set<uint32_t> seen;
for (const auto& [a, b] : next) {
if (seen.count(a)) continue;
++r.borderLoops;
uint32_t v = a;
for (size_t guard = 0; guard <= next.size() && !seen.count(v); ++guard) {
seen.insert(v);
const auto it = next.find(v);
if (it == next.end()) break;
v = it->second;
}
}
return r;
}
std::string readAll(const std::string& path) {
std::ifstream f(path, std::ios::binary);
std::stringstream s;
s << f.rdbuf();
return s.str();
}
} // namespace
TEST(garment_tshirt_template_is_valid_and_matched) {
const Pattern pat = tshirtPattern();
CHECK(pat.panels.size() == 4);
CHECK(pat.seams.size() == 10);
CHECK(patternProblems(pat).empty());
for (const Seam& s : pat.seams) {
const SeamCheck c = checkSeam(pat, s);
CHECK(c.lengthsMatch);
CHECK(!c.twisted);
}
for (const Panel& p : pat.panels) CHECK(panelArea(p) > 0.0f);
// Real size: the front is about half the chest plus ease wide and 70 cm long.
const glm::vec2 size = panelMax(pat.panels[0]) - panelMin(pat.panels[0]);
CHECK(std::abs(size.x - 520.0f) < 1.0f && std::abs(size.y - 700.0f) < 1.0f);
}
TEST(garment_triangulation_is_even_and_covers_each_panel) {
Pattern pat = tshirtPattern();
for (float h : {10.0f, 15.0f, 25.0f}) {
pat.particleDistance = h;
GarmentMesh m;
std::string error;
CHECK(triangulatePattern(pat, m, error));
CHECK(error.empty());
// Exactly the outline's area (the outline is sampled as chords: curves lose a sliver).
for (uint32_t p = 0; p < pat.panels.size(); ++p) {
const float want = panelArea(pat.panels[p]), got = meshArea(m, p);
CHECK(std::abs(got - want) < 0.01f * want);
}
const MeshQuality q = meshQuality(m, h);
CHECK(q.minAngle > 20.0f);
CHECK(q.minEdge > 0.4f && q.maxEdge < 1.8f);
// About one particle per equilateral triangle pair: area / (0.866 h^2).
double area = 0.0;
for (const Panel& p : pat.panels) area += panelArea(p);
const double expect = area / (0.866 * h * h);
CHECK(double(m.vertexCount()) > 0.8 * expect && double(m.vertexCount()) < 1.4 * expect);
// Every triangle counter-clockwise (faces out once placed).
bool ccw = true;
for (const glm::uvec3& t : m.triangles) {
const glm::vec2 u = m.flat[t.y] - m.flat[t.x], v = m.flat[t.z] - m.flat[t.x];
ccw = ccw && u.x * v.y - u.y * v.x > 0.0f;
}
CHECK(ccw);
}
}
TEST(garment_sewn_tshirt_welds_into_one_oriented_surface) {
const Pattern pat = tshirtPattern();
GarmentMesh m;
std::string error;
CHECK(triangulatePattern(pat, m, error));
// One link per point along each seam, both sides the same count.
CHECK(!m.links.empty());
std::vector<glm::vec3> rest;
flatRest(m, rest);
CHECK(rest.size() == m.vertexCount() && std::abs(rest[0].x - m.flat[0].x * 0.001f) < 1e-6f && rest[0].z == 0.0f);
const Mesh flat = garmentToMesh(m, rest, 0.0f);
CHECK(flat.triangleCount() == m.triangles.size());
const Topology t = topology(flat);
CHECK(t.manifold);
CHECK(t.consistent); // seams sewn the right way round: no panel turned over
CHECK(t.borderLoops == 4); // hem, neck, two sleeve hems
CHECK(flat.uvs.size() == flat.triangleCount() * 3);
bool inUnit = true;
for (glm::vec2 uv : flat.uvs) inUnit = inUnit && uv.x >= 0 && uv.x <= 1 && uv.y >= 0 && uv.y <= 1;
CHECK(inUnit);
std::set<uint32_t> groups(flat.facegroups.begin(), flat.facegroups.end());
CHECK(groups == std::set<uint32_t>({1, 2, 3, 4}));
// Thickened: closed (no border at all) and still consistently oriented.
const Mesh thick = garmentToMesh(m, rest, 2.0f);
const Topology tt = topology(thick);
CHECK(tt.manifold && tt.consistent && tt.borderLoops == 0);
CHECK(thick.vertexCount() == 2 * flat.vertexCount());
}
TEST(garment_flipped_seam_is_reported_and_twists) {
Pattern pat = tshirtPattern();
pat.seams[0].flipped = true;
CHECK(checkSeam(pat, pat.seams[0]).twisted);
CHECK(!patternProblems(pat).empty());
GarmentMesh m;
std::string error;
CHECK(triangulatePattern(pat, m, error));
std::vector<glm::vec3> rest;
flatRest(m, rest);
CHECK(!topology(garmentToMesh(m, rest, 0.0f)).consistent);
}
TEST(garment_pattern_round_trips_json_and_project) {
Pattern pat = tshirtPattern(1000.0f, 650.0f);
pat.particleDistance = 12.0f;
pat.fabric = "denim";
pat.seams[3].flipped = true;
Pattern back;
std::string error;
CHECK(patternFromJson(patternToJson(pat), back, error));
CHECK(patternToJson(back).dump() == patternToJson(pat).dump());
// In a project.
Document doc = makeDoc(makeIcosphere(2));
setDocumentPattern(doc, pat);
const std::string path = tempPath("garment_roundtrip.sfproj");
CHECK(saveProject(path, doc, error));
Document loaded;
CHECK(loadProject(path, loaded, error));
Pattern got;
CHECK(documentPattern(loaded, got));
CHECK(patternToJson(got).dump() == patternToJson(pat).dump());
std::remove(path.c_str());
// Hostile JSON: wrong types, huge counts, bad seams are refused or dropped, never crash.
Json j;
CHECK(Json::parse(R"({"panels":[{"name":"x","points":[0,0,1e30,0,0,5]},{"points":"no"},
{"name":"ok","points":[0,0,100,0,100,100,0,100],"curves":[[99,0,0,0,0]],"notches":[[-1,2]]}],
"seams":[{"a":[0,0,0,1],"b":[5,0,0,1]},{"a":[0,0,0.5,0.2],"b":[0,1,0,1]}]})",
j, error));
Pattern bad;
error.clear();
CHECK(patternFromJson(j, bad, error));
CHECK(bad.panels.size() == 1 && bad.panels[0].name == "ok" && bad.seams.empty());
CHECK(!error.empty());
}
TEST(garment_svg_round_trips_at_real_size) {
const Pattern pat = tshirtPattern();
const std::string svg = patternToSvg(pat);
CHECK(svg.find("mm\" height=") != std::string::npos);
CHECK(svg.find("class=\"cut\"") != std::string::npos && svg.find("class=\"notch\"") != std::string::npos);
std::vector<Panel> panels;
std::string error;
CHECK(panelsFromSvg(svg, panels, error) == 4);
CHECK(error.empty());
for (size_t i = 0; i < panels.size(); ++i) {
CHECK(panels[i].name == pat.panels[i].name);
CHECK(std::abs(panelArea(panels[i]) - panelArea(pat.panels[i])) < 0.002f * panelArea(pat.panels[i]));
CHECK(std::abs(perimeter(panels[i]) - perimeter(pat.panels[i])) < 1.0f);
CHECK(panels[i].points.size() == pat.panels[i].points.size());
}
const std::string dxf = patternToDxf(pat);
CHECK(dxf.find("$INSUNITS") != std::string::npos && dxf.find("POLYLINE") != std::string::npos);
CHECK(dxf.find("SEW") != std::string::npos && dxf.find("CUT") != std::string::npos);
CHECK(dxf.substr(dxf.size() - 4) == "EOF\n");
}
TEST(garment_svg_import_reads_units_transforms_and_shapes) {
// A 10 x 20 cm rectangle in a cm document, a translated triangle path (relative commands), a polygon in a
// scaled group, an open path (ignored) and a quadratic curve.
const std::string svg = R"svg(<?xml version="1.0"?>
<!DOCTYPE svg [ <!ENTITY big "aaaaaaaaaaaaaaaaaaaa"> ]>
<svg xmlns="http://www.w3.org/2000/svg" width="50cm" height="50cm" viewBox="0 0 50 50">
<!-- a comment with <rect x="0" y="0" width="1" height="1"/> inside -->
<rect id="Front" x="1" y="1" width="10" height="20"/>
<path id="tri" transform="translate(30 5)" d="m0,0 l10,0 l-5-8.66z"/>
<g transform="scale(2)"><polygon id="poly" points="1,30 6,30 6,35"/></g>
<path d="M0 0 L 5 5"/>
<path id="curve" d="M 20 40 Q 25 30 30 40 Z"/>
</svg>)svg";
std::vector<Panel> panels;
std::string error;
CHECK(panelsFromSvg(svg, panels, error) == 4);
if (panels.size() != 4) {
std::printf(" svg import: %zu panels (%s)\n", panels.size(), error.c_str());
for (const Panel& p : panels) std::printf(" %s %zu points area %.1f\n", p.name.c_str(), p.points.size(), double(panelArea(p)));
return;
}
CHECK(panels[0].name == "Front");
CHECK(std::abs(panelArea(panels[0]) - 100.0f * 200.0f) < 1.0f); // mm^2
CHECK(std::abs(panelArea(panels[1]) - 0.5f * 100.0f * 86.6f) < 5.0f);
CHECK(std::abs(panelArea(panels[2]) - 0.5f * 100.0f * 100.0f) < 5.0f); // scaled 2x: 10 x 10 cm triangle
CHECK(std::any_of(panels[3].curves.begin(), panels[3].curves.end(), [](const EdgeCurve& c) { return c.curved; }));
for (const Panel& p : panels) CHECK(panelArea(p) > 0.0f); // counter-clockwise after the y flip
// px documents (no units): 96 per inch.
panels.clear();
CHECK(panelsFromSvg(R"(<svg width="200" height="200"><rect width="96" height="96"/></svg>)", panels, error) == 1);
CHECK(!panels.empty() && std::abs(panelArea(panels[0]) - 25.4f * 25.4f) < 0.5f);
}
TEST(garment_svg_reader_survives_hostile_input) {
std::vector<Panel> panels;
std::string error;
CHECK(panelsFromSvg("", panels, error) == 0);
CHECK(panelsFromSvg("<svg><path d=\"M 1e999 0 L 0 1e999 L 5 5 Z\"/></svg>", panels, error) == 0);
CHECK(panelsFromSvg("<svg><path d=\"M0 0 L" + std::string(100000, '9') + " 0 Z\"/></svg>", panels, error) == 0);
CHECK(panelsFromSvg(std::string(5u << 20, '<'), panels, error) == 0); // over 4 MB
// Mutations of a real pattern: random bytes changed, inserted, cut. Never a crash or a hang.
const std::string base = patternToSvg(tshirtPattern());
std::mt19937 rng(7);
const auto start = std::chrono::steady_clock::now();
for (int i = 0; i < 300; ++i) {
std::string s = base;
const int edits = 1 + int(rng() % 20);
for (int e = 0; e < edits; ++e) {
const size_t at = rng() % s.size();
switch (rng() % 3) {
case 0: s[at] = char(rng() % 256); break;
case 1: s.insert(at, 1, "<>\"'=-.eE0zZmMcC/"[rng() % 17]); break;
default: s.erase(at, std::min<size_t>(s.size() - at, rng() % 40)); break;
}
}
panels.clear();
panelsFromSvg(s, panels, error);
for (const Panel& p : panels) CHECK(validPanel(p, error));
}
CHECK(std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count() < timeLimit(20.0));
}
TEST(garment_svg_import_bounds_flattened_curves) {
// 512 panels of 39 wild cubic edges each: under the 20,000 input-point cap, but every curve flattens to up to
// 512 segments. The import stops at 50,000 outline points in all and says so, quickly.
std::string svg = "<svg width=\"100cm\" viewBox=\"0 0 1000 1000\">";
std::mt19937 rng(3);
for (int k = 0; k < 512; ++k) {
svg += "<path d=\"M 0 0";
for (int e = 0; e < 39; ++e)
svg += " C " + std::to_string(rng() % 1000) + " " + std::to_string(rng() % 1000) + " " + std::to_string(rng() % 1000) + " " +
std::to_string(rng() % 1000) + " " + std::to_string(rng() % 1000) + " " + std::to_string(rng() % 1000);
svg += " Z\"/>";
}
svg += "</svg>";
std::vector<Panel> panels;
std::string error;
const auto start = std::chrono::steady_clock::now();
panelsFromSvg(svg, panels, error);
CHECK(std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count() < timeLimit(2.0));
CHECK(error.find("not read") != std::string::npos);
// Groups nested past the 64-deep stack: their closing tags don't pop the real groups' transforms.
std::string deep = "<svg width=\"100mm\" viewBox=\"0 0 100 100\"><g transform=\"translate(10 0)\">";
for (int k = 0; k < 100; ++k) deep += "<g>";
for (int k = 0; k < 100; ++k) deep += "</g>";
deep += "<rect x=\"0\" y=\"0\" width=\"10\" height=\"10\"/></g></svg>";
panels.clear();
CHECK(panelsFromSvg(deep, panels, error) == 1);
CHECK(!panels.empty() && std::abs(panelMin(panels[0]).x - 10.0f) < 0.01f);
}
TEST(garment_crossing_check_matches_brute_force) {
// The grid crossing check against an all-pairs test on random polygons (many cross, some don't).
std::mt19937 rng(11);
int crossing = 0, clean = 0;
for (int t = 0; t < 400; ++t) {
Panel p;
const int n = 3 + int(rng() % 40);
const bool star = t % 2; // star-shaped: never crosses; else random points: usually crosses
for (int k = 0; k < n; ++k) {
const float a = 6.2831853f * float(k) / float(n);
const float r = 50.0f + float(rng() % 1000);
p.points.push_back(star ? glm::vec2(std::cos(a), std::sin(a)) * r : glm::vec2(float(rng() % 2000), float(rng() % 2000)));
p.curves.push_back({});
}
const std::vector<glm::vec2> o = outline(p, 0.5f);
const size_t m = o.size();
auto cross = [](glm::vec2 a, glm::vec2 b, glm::vec2 c, glm::vec2 d) {
auto x = [](glm::vec2 u, glm::vec2 v) { return u.x * v.y - u.y * v.x; };
const float d1 = x(b - a, c - a), d2 = x(b - a, d - a), d3 = x(d - c, a - c), d4 = x(d - c, b - c);
return ((d1 > 0) != (d2 > 0)) && ((d3 > 0) != (d4 > 0)) && d1 != 0 && d2 != 0 && d3 != 0 && d4 != 0;
};
bool brute = false;
for (size_t i = 0; i < m && !brute; ++i)
for (size_t j = i + 2; j < m && !brute; ++j)
if (!(i == 0 && j == m - 1)) brute = cross(o[i], o[(i + 1) % m], o[j], o[(j + 1) % m]);
std::string why;
const bool ok = validPanel(p, why);
if (why.find("crosses") != std::string::npos || ok) CHECK(ok == !brute);
(brute ? crossing : clean)++;
}
CHECK(crossing > 50 && clean > 50);
}
TEST(garment_edits_keep_seams_and_shapes) {
// Mirror twice: the same panel; area unchanged.
Pattern pat = tshirtPattern();
mirrorPanel(pat, 2);
CHECK(panelArea(pat.panels[2]) > 0.0f);
CHECK(patternProblems(pat).empty());
mirrorPanel(pat, 2);
std::string error;
CHECK(std::abs(panelArea(pat.panels[2]) - panelArea(tshirtPattern().panels[2])) < 1.0f);
CHECK(pat.seams.size() == 10);
// Unfold a half: a 100 x 300 half about its left edge (edge 4, from (0,300) down to (0,0)) doubles.
Pattern half;
half.panels.push_back(rectanglePanel("Front", 100.0f, 300.0f));
CHECK(unfoldPanel(half, 0, 3, error));
CHECK(std::abs(panelArea(half.panels[0]) - 2.0f * 100.0f * 300.0f) < 1.0f);
CHECK(half.panels[0].points.size() == 6); // the fold's two points stay as corners of the hem and top
CHECK(validPanel(half.panels[0], error));
// Split an edge under a seam end: the seam moves with its piece; removing a point drops seams on it.
Pattern s;
s.panels.push_back(rectanglePanel("A", 100.0f, 100.0f));
s.panels.push_back(rectanglePanel("B", 100.0f, 100.0f, {200.0f, 0.0f}));
CHECK(addSeam(s, {{0, 1, 0.0f, 0.5f}, {1, 3, 0.5f, 1.0f}, false}, error));
CHECK(!addSeam(s, {{0, 1, 0.25f, 0.75f}, {1, 1, 0.0f, 1.0f}, false}, error)); // overlaps
splitEdge(s, 0, 1, 0.5f);
CHECK(s.panels[0].points.size() == 5 && s.seams.size() == 1);
CHECK(s.seams[0].a.edge == 1 && std::abs(s.seams[0].a.t1 - 1.0f) < 1e-4f);
CHECK(std::abs(seamSideLength(s, s.seams[0].a) - 50.0f) < 0.01f);
CHECK(removePoint(s, 0, 2));
CHECK(s.seams.empty() && s.panels[0].points.size() == 4);
// Mirrored copy: the other arm.
Pattern t = tshirtPattern();
const uint32_t c = mirroredCopy(t, 2, "Extra");
CHECK(t.panels[c].name == "Extra" && t.seams.size() == tshirtPattern().seams.size()); // (no seams added)
}
TEST(garment_triangulates_quickly) {
Pattern pat = tshirtPattern();
pat.particleDistance = 10.0f; // about 9,000 particles
GarmentMesh m;
std::string error;
const auto t0 = std::chrono::steady_clock::now();
CHECK(triangulatePattern(pat, m, error));
const double s = std::chrono::duration<double>(std::chrono::steady_clock::now() - t0).count();
std::printf(" garment: %zu particles, %zu triangles in %.0f ms\n", m.vertexCount(), m.triangles.size(), s * 1000.0);
CHECK(s < timeLimit(1.0));
}
TEST(garment_commands_make_sew_and_export) {
CommandRegistry reg;
Document doc = makeDoc(makeIcosphere(2));
CHECK(!reg.execute(doc, "garment_info").ok);
CommandResult r = reg.execute(doc, "garment_new", {{"template", std::string("tshirt")}});
CHECK(r.ok && r.message.find("4 panels, 10 seams") != std::string::npos);
CHECK(reg.execute(doc, "garment_info").message.find("Left sleeve") != std::string::npos);
r = reg.execute(doc, "garment_add_panel", {{"name", std::string("Pocket")}, {"width_mm", 120.0}, {"height_mm", 140.0}});
CHECK(r.ok);
r = reg.execute(doc, "garment_add_panel", {{"name", std::string("Bad")}, {"points", std::string("[0,0,1,1]")}});
CHECK(!r.ok);
r = reg.execute(doc, "garment_sew", {{"a_panel", std::string("Pocket")}, {"a_edge", 1.0}, {"b_panel", std::string("front")},
{"b_edge", 1.0}, {"b_from", 0.1}, {"b_to", 0.3}});
CHECK(r.ok); // the front hem is free
CHECK(reg.execute(doc, "garment_set", {{"particle_mm", 20.0}, {"fabric", std::string("silk")}}).ok);
CHECK(!reg.execute(doc, "garment_set", {{"fabric", std::string("tweed")}}).ok);
const std::string svg = tempPath("garment_cmd.svg"), dxf = tempPath("garment_cmd.dxf");
CHECK(reg.execute(doc, "garment_export", {{"path", svg}}).ok);
CHECK(reg.execute(doc, "garment_export", {{"path", dxf}}).ok);
CHECK(readAll(dxf).find("POLYLINE") != std::string::npos);
// Import our own file into a fresh pattern: the five panels come back.
CHECK(reg.execute(doc, "garment_new", {{"template", std::string("empty")}}).ok);
r = reg.execute(doc, "garment_import", {{"path", svg}});
CHECK(r.ok && r.message.find("Imported 5 panels") != std::string::npos);
Pattern got;
CHECK(documentPattern(doc, got) && got.panels.size() == 5);
CHECK(reg.execute(doc, "garment_clear").ok && !documentPattern(doc, got));
std::remove(svg.c_str());
std::remove(dxf.c_str());
}