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
//
// garment_* commands (core/Garment.h): make and edit the scene's garment pattern, sew it, write and read
// pattern files. The pattern lives in the project (Document::projectSettings["garment"]).
#include "core/Commands.h"
#include "core/Garment.h"
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cctype>
#include <limits>
#include <fstream>
#include <sstream>
namespace sf {
namespace {
using namespace garment;
using T = ParamSpec::Type;
std::string lower(std::string s) {
std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return char(std::tolower(c)); });
return s;
}
// A panel by name (any case) or 1-based number.
bool findPanel(const Pattern& pat, const std::string& ref, uint32_t& out, std::string& error) {
for (uint32_t i = 0; i < pat.panels.size(); ++i)
if (lower(pat.panels[i].name) == lower(ref)) {
out = i;
return true;
}
char* end = nullptr;
const long n = std::strtol(ref.c_str(), &end, 10);
if (!ref.empty() && end && *end == 0 && n >= 1 && size_t(n) <= pat.panels.size()) {
out = uint32_t(n - 1);
return true;
}
error = "No panel \"" + ref + "\" in the pattern";
return false;
}
bool loadOrFail(const Document& doc, Pattern& pat, CommandResult& r) {
if (documentPattern(doc, pat)) return true;
r = {false, "No garment pattern: run garment_new first"};
return false;
}
std::string summary(const Pattern& pat) {
std::ostringstream s;
s << pat.panels.size() << " panels, " << pat.seams.size() << " seams";
GarmentMesh m;
std::string error;
if (!pat.panels.empty() && triangulatePattern(pat, m, error))
s << ", " << m.vertexCount() << " particles at " << pat.particleDistance << " mm";
return s.str();
}
bool writeText(const std::string& path, const std::string& text, std::string& error) {
std::ofstream f(path, std::ios::binary);
if (!f || !f.write(text.data(), std::streamsize(text.size()))) {
error = "Could not write " + path;
return false;
}
return true;
}
CommandResult seamCommand(Document& doc, const Args& a) {
CommandResult r;
Pattern pat;
if (!loadOrFail(doc, pat, r)) return r;
Seam s;
std::string error;
for (int side = 0; side < 2; ++side) {
const std::string p = side ? "b_" : "a_";
SeamSide& sd = side ? s.b : s.a;
if (!findPanel(pat, argString(a, p + "panel"), sd.panel, error)) return {false, error};
const double e = argNumber(a, p + "edge", 0);
if (!(e >= 1 && e <= double(pat.panels[sd.panel].points.size())))
return {false, "No edge " + std::to_string(int(e)) + " on " + pat.panels[sd.panel].name};
sd.edge = uint32_t(e) - 1;
sd.t0 = float(std::clamp(argNumber(a, p + "from", 0.0), 0.0, 1.0));
sd.t1 = float(std::clamp(argNumber(a, p + "to", 1.0), 0.0, 1.0));
}
s.flipped = argBool(a, "flipped", false);
if (!addSeam(pat, s, error)) return {false, error};
setDocumentPattern(doc, pat);
const SeamCheck c = checkSeam(pat, s);
return {true, "Sewed " + c.text};
}
} // namespace
void registerGarmentCommands(CommandRegistry& reg) {
reg.add({"garment_new",
"Garments: start a garment pattern in the scene (saved with the project). template: tshirt (front, back "
"and two sleeves, sewn and placed: ready to drape) or empty.",
{{"template", T::String, "tshirt (default) or empty", false},
{"chest_mm", T::Number, "T-shirt: the body's chest girth in mm (default 960)", false},
{"length_mm", T::Number, "T-shirt: length from the shoulder in mm (default 700)", false},
{"particle_mm", T::Number, "Distance between the cloth's particles in mm (default 15)", false}},
[](Document& doc, const Args& a) -> CommandResult {
const std::string t = lower(argString(a, "template", "tshirt"));
Pattern pat;
if (t == "tshirt" || t == "t-shirt")
pat = tshirtPattern(float(argNumber(a, "chest_mm", 960.0)), float(argNumber(a, "length_mm", 700.0)));
else if (t != "empty")
return {false, "Unknown template \"" + t + "\" (tshirt or empty)"};
pat.particleDistance = float(std::clamp(argNumber(a, "particle_mm", pat.particleDistance), 2.0, 200.0));
if (pat.empty()) {
doc.projectSettings.set("garment", patternToJson(pat)); // an empty pattern to draw in
doc.modified = true;
return {true, "New empty garment pattern"};
}
setDocumentPattern(doc, pat);
return {true, "New garment pattern: " + summary(pat)};
}});
reg.add({"garment_info", "Garments: the pattern's panels, seams (with their lengths) and any problems.", {},
[](Document& doc, const Args&) -> CommandResult {
CommandResult r;
Pattern pat;
if (!loadOrFail(doc, pat, r)) return r;
std::ostringstream s;
s << summary(pat);
for (size_t i = 0; i < pat.panels.size(); ++i) {
const Panel& p = pat.panels[i];
const glm::vec2 size = panelMax(p) - panelMin(p);
char buf[200];
std::snprintf(buf, sizeof buf, "\n%zu. %s: %.0f x %.0f mm, %zu edges", i + 1, p.name.c_str(),
double(size.x), double(size.y), p.points.size());
s << buf;
}
for (const Seam& sm : pat.seams) s << "\nSeam " << checkSeam(pat, sm).text;
for (const std::string& pr : patternProblems(pat)) s << "\nProblem: " << pr;
return {true, s.str()};
}});
reg.add({"garment_add_panel",
"Garments: add a pattern panel from its outline: points as JSON [x0, y0, x1, y1, ...] in mm (y up), "
"or a rectangle from width_mm and height_mm.",
{{"name", T::String, "Panel name", false},
{"points", T::String, "Outline as JSON [x0, y0, x1, y1, ...] in mm, 3 points or more", false},
{"width_mm", T::Number, "Rectangle width (when no points)", false},
{"height_mm", T::Number, "Rectangle height (when no points)", false}},
[](Document& doc, const Args& a) -> CommandResult {
Pattern pat;
documentPattern(doc, pat);
Panel p;
const std::string pts = argString(a, "points");
const std::string name = argString(a, "name", "Panel " + std::to_string(pat.panels.size() + 1));
if (!pts.empty()) {
Json j;
std::string error;
if (!Json::parse(pts, j, error) || !j.isArray() || j.size() % 2 || j.size() < 6)
return {false, "points must be a JSON array [x0, y0, x1, y1, ...] of 3 points or more"};
for (size_t k = 0; k + 1 < j.size() && k < 40000; k += 2)
p.points.push_back({float(j[k].asNumber()), float(j[k + 1].asNumber())});
p.curves.resize(p.points.size());
p.name = name;
} else {
const float w = float(argNumber(a, "width_mm", 0.0)), h = float(argNumber(a, "height_mm", 0.0));
if (!(w >= 1.0f && h >= 1.0f && w < 1e5f && h < 1e5f)) return {false, "Give points or width_mm and height_mm"};
float x = 0.0f;
for (const Panel& q : pat.panels) x = std::max(x, panelMax(q).x + 60.0f);
p = rectanglePanel(name, w, h, {x, 0.0f});
}
normalizePanel(p);
std::string error;
if (!validPanel(p, error)) return {false, error};
pat.panels.push_back(std::move(p));
setDocumentPattern(doc, pat);
return {true, "Added " + pat.panels.back().name + ": " + summary(pat)};
}});
reg.add({"garment_remove_panel", "Garments: remove a panel (and its seams).",
{{"panel", T::String, "Panel name or number", true}},
[](Document& doc, const Args& a) -> CommandResult {
CommandResult r;
Pattern pat;
if (!loadOrFail(doc, pat, r)) return r;
uint32_t i;
std::string error;
if (!findPanel(pat, argString(a, "panel"), i, error)) return {false, error};
const std::string name = pat.panels[i].name;
removePanel(pat, i);
setDocumentPattern(doc, pat);
return {true, "Removed " + name};
}});
reg.add({"garment_mirror_copy",
"Garments: add a mirrored copy of a panel (the other sleeve or side), placed on the other side of the body.",
{{"panel", T::String, "Panel name or number", true}, {"name", T::String, "The copy's name", false}},
[](Document& doc, const Args& a) -> CommandResult {
CommandResult r;
Pattern pat;
if (!loadOrFail(doc, pat, r)) return r;
uint32_t i;
std::string error;
if (!findPanel(pat, argString(a, "panel"), i, error)) return {false, error};
const uint32_t j = mirroredCopy(pat, i, argString(a, "name"));
setDocumentPattern(doc, pat);
return {true, "Added " + pat.panels[j].name};
}});
reg.add({"garment_sew",
"Garments: sew an edge range of one panel to an edge range of another (or the same) panel. Edges are "
"numbered from 1 (edge 1 runs from point 1 to point 2); from/to are fractions of the edge (0-1). Sewn "
"the right way, a's start meets b's end; flipped=true sews start to start (twists the fabric).",
{{"a_panel", T::String, "First panel (name or number)", true},
{"a_edge", T::Number, "Its edge (1-based)", true},
{"a_from", T::Number, "Range start along it (default 0)", false},
{"a_to", T::Number, "Range end (default 1)", false},
{"b_panel", T::String, "Second panel", true},
{"b_edge", T::Number, "Its edge (1-based)", true},
{"b_from", T::Number, "Range start (default 0)", false},
{"b_to", T::Number, "Range end (default 1)", false},
{"flipped", T::Bool, "Sew start to start (default false)", false}},
seamCommand});
reg.add({"garment_unsew", "Garments: remove a seam.", {{"seam", T::Number, "Seam number (1-based, see garment_info)", true}},
[](Document& doc, const Args& a) -> CommandResult {
CommandResult r;
Pattern pat;
if (!loadOrFail(doc, pat, r)) return r;
const double n = argNumber(a, "seam", 0);
if (!(n >= 1 && n <= double(pat.seams.size()))) return {false, "No such seam"};
pat.seams.erase(pat.seams.begin() + long(n - 1));
setDocumentPattern(doc, pat);
return {true, "Removed seam " + std::to_string(int(n))};
}});
reg.add({"garment_set", "Garments: the pattern's simulation settings.",
{{"particle_mm", T::Number, "Distance between particles in mm (2-200; smaller = finer folds, slower)", false},
{"fabric", T::String, "silk, cotton, denim or leather", false},
{"thickness_mm", T::Number, "Thickness of the Part made from the garment (0 = a single surface)", false}},
[](Document& doc, const Args& a) -> CommandResult {
CommandResult r;
Pattern pat;
if (!loadOrFail(doc, pat, r)) return r;
if (a.count("particle_mm")) pat.particleDistance = float(std::clamp(argNumber(a, "particle_mm", 15), 2.0, 200.0));
if (a.count("thickness_mm")) pat.thickness = float(std::clamp(argNumber(a, "thickness_mm", 2), 0.0, 100.0));
if (a.count("fabric")) {
const std::string f = lower(argString(a, "fabric"));
if (f != "silk" && f != "cotton" && f != "denim" && f != "leather") return {false, "Unknown fabric \"" + f + "\""};
pat.fabric = f;
}
setDocumentPattern(doc, pat);
return {true, "Garment: " + summary(pat) + ", " + pat.fabric};
}});
reg.add({"garment_export",
"Garments: write the pattern at real size for sewing: svg (sewing and cutting lines, notches, grain "
"lines, names, a 50 mm scale square; print at 100%) or dxf (outlines in mm).",
{{"path", T::String, "File to write (.svg or .dxf)", true}, {"format", T::String, "svg or dxf (default: from the path)", false}},
[](Document& doc, const Args& a) -> CommandResult {
CommandResult r;
Pattern pat;
if (!loadOrFail(doc, pat, r)) return r;
if (pat.empty()) return {false, "The pattern has no panels"};
const std::string path = argString(a, "path");
std::string fmt = lower(argString(a, "format"));
if (fmt.empty()) fmt = lower(path).size() > 4 && lower(path).substr(lower(path).size() - 4) == ".dxf" ? "dxf" : "svg";
std::string error;
if (!writeText(path, fmt == "dxf" ? patternToDxf(pat) : patternToSvg(pat), error)) return {false, error};
return {true, "Wrote " + std::to_string(pat.panels.size()) + " panels to " + path};
}});
reg.add({"garment_import", "Garments: add panels from an SVG (every closed shape, at the file's real size).",
{{"path", T::String, "SVG file", true}},
[](Document& doc, const Args& a) -> CommandResult {
const std::string path = argString(a, "path");
std::ifstream f(path, std::ios::binary);
if (!f) return {false, "Could not open " + path};
f.seekg(0, std::ios::end);
const std::streamoff size = f.tellg();
if (size < 0 || size > 4 * 1024 * 1024) return {false, "The SVG is larger than 4 MB"};
f.seekg(0);
std::string text(size_t(size), '\0');
f.read(text.data(), size);
Pattern pat;
documentPattern(doc, pat);
std::vector<Panel> panels;
std::string error;
const int n = panelsFromSvg(text, panels, error);
if (!n) return {false, error};
// Beside what's there already.
float x = 0.0f;
for (const Panel& q : pat.panels) x = std::max(x, panelMax(q).x + 60.0f);
float minX = std::numeric_limits<float>::max(), minY = minX;
for (const Panel& p : panels) {
minX = std::min(minX, panelMin(p).x);
minY = std::min(minY, panelMin(p).y);
}
const glm::vec2 shift(x - minX, -minY);
for (Panel& p : panels) {
for (glm::vec2& q : p.points) q += shift;
for (EdgeCurve& c : p.curves) {
c.c1 += shift;
c.c2 += shift;
}
}
pat.panels.insert(pat.panels.end(), panels.begin(), panels.end());
setDocumentPattern(doc, pat);
return {true, "Imported " + std::to_string(n) + " panels" + (error.empty() ? "" : " (" + error + ")")};
}});
reg.add({"garment_clear", "Garments: remove the garment pattern from the scene.", {},
[](Document& doc, const Args&) -> CommandResult {
setDocumentPattern(doc, Pattern{});
return {true, "Garment pattern removed"};
}});
}
} // namespace sf