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
//
// Transforms (core/MeshTransform.h, the Transform gizmo and the `transform` command): exact results, masked parts with a
// smooth falloff, sculpt layers, symmetry, All Parts, attributes left alone and bit-for-bit undo.
#include "TestHarness.h"
#include "core/Commands.h"
#include "core/MeshTransform.h"
#include "core/Primitives.h"
#include "core/Project.h"
#include "core/Parts.h"
#include <glm/gtc/matrix_transform.hpp>
#include <algorithm>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <filesystem>
using namespace sf;
namespace {
const CommandRegistry& registry() {
static CommandRegistry r;
return r;
}
CommandResult run(Document& d, const std::string& name, const Args& a = {}) { return registry().execute(d, name, a); }
template <class V> bool sameBits(const std::vector<V>& a, const std::vector<V>& b) {
return a.size() == b.size() && (a.empty() || std::memcmp(a.data(), b.data(), a.size() * sizeof(V)) == 0);
}
float maxDistance(const std::vector<glm::vec3>& a, const std::vector<glm::vec3>& b) {
float d = 0.0f;
for (size_t i = 0; i < a.size(); ++i) d = std::max(d, glm::length(a[i] - b[i]));
return d;
}
// Mask = 1 where x < edge.
void maskBelowX(Mesh& m, float edge) {
m.ensureMask();
for (uint32_t v = 0; v < m.vertexCount(); ++v) m.mask[v] = m.positions[v].x < edge ? 1.0f : 0.0f;
}
// A capsule-like arm: a sphere stretched along X.
Mesh makeArm(int subdivisions = 4) {
Mesh m = makeIcosphere(subdivisions, 1.0f);
for (auto& p : m.positions) p *= glm::vec3(3.0f, 0.6f, 0.6f);
m.recomputeAllNormals();
return m;
}
} // namespace
TEST(transform_translate_is_exact) {
Document d = makeDoc(makeIcosphere(3));
const auto before = d.mesh.positions;
const CommandResult moved = run(d, "transform", {{"translate", std::string("0.25,-1,3")}});
CHECK(moved.ok);
CHECK(moved.message == "Moved " + vertexCountText(before.size())); // a plain sentence, no raw pivot floats
bool exact = true;
for (size_t v = 0; v < before.size(); ++v) exact = exact && d.mesh.positions[v] == before[v] + glm::vec3(0.25f, -1.0f, 3.0f);
CHECK(exact);
CHECK(d.undo.canUndo());
}
TEST(transform_status_counts_read_as_text) {
CHECK(vertexCountText(1) == "1 vertex");
CHECK(vertexCountText(642) == "642 vertices");
CHECK(vertexCountText(2562) == "2,562 vertices");
CHECK(vertexCountText(1234567) == "1,234,567 vertices");
Document d = makeDoc(makeIcosphere(3));
CHECK(run(d, "transform", {{"rotate", std::string("0,90,0")}}).message.rfind("Turned ", 0) == 0);
CHECK(run(d, "transform", {{"scale", 2.0}}).message.rfind("Scaled ", 0) == 0);
CHECK(run(d, "transform", {{"scale", 0.5}, {"translate", std::string("1,0,0")}}).message.rfind("Transformed ", 0) == 0);
}
TEST(transform_matches_the_formula) {
Document d = makeDoc(makeIcosphere(3));
const auto before = d.mesh.positions;
CHECK(run(d, "transform",
{{"translate", std::string("1,2,3")}, {"rotate", std::string("30,-45,60")}, {"scale", std::string("2,1,0.5")},
{"pivot", std::string("0.5,0,-0.25")}})
.ok);
// Independent: p' = pivot + t + Rz Ry Rx S (p - pivot), built from glm matrices.
glm::mat4 r(1.0f);
r = glm::rotate(r, glm::radians(60.0f), glm::vec3(0, 0, 1));
r = glm::rotate(r, glm::radians(-45.0f), glm::vec3(0, 1, 0));
r = glm::rotate(r, glm::radians(30.0f), glm::vec3(1, 0, 0));
const glm::vec3 pivot(0.5f, 0.0f, -0.25f), t(1, 2, 3), s(2, 1, 0.5f);
float err = 0.0f;
for (size_t v = 0; v < before.size(); ++v) {
const glm::vec3 want = pivot + t + glm::vec3(r * glm::vec4((before[v] - pivot) * s, 0.0f));
err = std::max(err, glm::length(d.mesh.positions[v] - want));
}
CHECK(err < 1e-5f);
// Normals follow (a sphere's normals are its directions; scaled non-uniformly they tilt accordingly).
float dot = 1.0f;
for (size_t v = 0; v < before.size(); ++v) dot = std::min(dot, glm::length(d.mesh.normals[v]));
CHECK(dot > 0.999f);
}
TEST(transform_rotate_and_scale_about_centre) {
Document d = makeDoc(makeIcosphere(3));
for (auto& p : d.mesh.positions) p += glm::vec3(5, 0, 0);
d.mesh.recomputeAllNormals();
d.bvh.build(d.mesh);
const auto before = d.mesh.positions;
CHECK(run(d, "transform", {{"rotate", std::string("0,90,0")}}).ok); // about the centre (5,0,0)
float err = 0.0f;
for (size_t v = 0; v < before.size(); ++v) {
const glm::vec3 q = before[v] - glm::vec3(5, 0, 0);
err = std::max(err, glm::length(d.mesh.positions[v] - (glm::vec3(5, 0, 0) + glm::vec3(q.z, q.y, -q.x))));
}
CHECK(err < 1e-5f);
CHECK(run(d, "transform", {{"scale", 2.0}}).ok);
const AABB b = d.mesh.bounds();
CHECK(std::abs(b.extent().x - 4.0f) < 1e-3f);
CHECK(glm::length(b.center() - glm::vec3(5, 0, 0)) < 1e-3f);
}
TEST(transform_undo_restores_bit_for_bit) {
Document d = makeDoc(makeArm());
const auto pos = d.mesh.positions, nrm = d.mesh.normals;
CHECK(run(d, "transform", {{"rotate", std::string("10,20,30")}, {"translate", std::string("0.1,0.2,0.3")}, {"scale", 1.5}}).ok);
const auto moved = d.mesh.positions;
CHECK(!sameBits(moved, pos));
CHECK(run(d, "undo").ok);
CHECK(sameBits(d.mesh.positions, pos));
CHECK(sameBits(d.mesh.normals, nrm));
CHECK(run(d, "redo").ok);
CHECK(sameBits(d.mesh.positions, moved));
// Masked, with a falloff: same.
CHECK(run(d, "undo").ok);
maskBelowX(d.mesh, 0.0f);
CHECK(run(d, "transform", {{"rotate", std::string("0,0,40")}, {"pivot", std::string("0,0,0")}, {"falloff", 0.1}}).ok);
CHECK(run(d, "undo").ok);
CHECK(sameBits(d.mesh.positions, pos));
CHECK(sameBits(d.mesh.normals, nrm));
}
TEST(transform_masked_part_only) {
Document d = makeDoc(makeArm());
maskBelowX(d.mesh, 0.0f);
const auto before = d.mesh.positions;
CHECK(run(d, "transform", {{"translate", std::string("0,1,0")}}).ok);
bool still = true, full = true;
for (size_t v = 0; v < before.size(); ++v) {
if (d.mesh.mask[v] >= 1.0f) still = still && d.mesh.positions[v] == before[v];
else full = full && d.mesh.positions[v] == before[v] + glm::vec3(0, 1, 0);
}
CHECK(still);
CHECK(full);
// masked=0 moves everything.
CHECK(run(d, "transform", {{"translate", std::string("0,1,0")}, {"masked", false}}).ok);
CHECK(d.mesh.positions[0].y > before[0].y + 0.5f);
// Everything masked: nothing to move.
std::fill(d.mesh.mask.begin(), d.mesh.mask.end(), 1.0f);
CHECK(!run(d, "transform", {{"translate", std::string("0,1,0")}}).ok);
}
TEST(transform_partial_mask_moves_partly) {
Document d = makeDoc(makeIcosphere(2));
d.mesh.ensureMask(0.25f); // 75% weight everywhere
const auto before = d.mesh.positions;
CHECK(run(d, "transform", {{"translate", std::string("4,0,0")}}).ok);
float err = 0.0f;
for (size_t v = 0; v < before.size(); ++v) err = std::max(err, glm::length(d.mesh.positions[v] - before[v] - glm::vec3(3, 0, 0)));
CHECK(err < 1e-2f); // weights are quantized to 1/4096
}
TEST(transform_falloff_is_smooth) {
Mesh arm = makeArm(5);
maskBelowX(arm, 0.0f);
// Weights: a hard 0/1 step without falloff, a gradual ramp with it.
auto steepest = [&](const std::vector<float>& w) {
float s = 0.0f;
for (uint32_t v = 0; v < arm.vertexCount(); ++v)
for (uint32_t n : arm.neighbors(v)) s = std::max(s, std::abs(w[v] - w[n]));
return s;
};
const auto hard = transformWeights(arm, true, 0);
const auto soft = transformWeights(arm, true, 0.15f);
CHECK(steepest(hard) == 1.0f);
CHECK(steepest(soft) < 0.25f);
for (float w : soft) CHECK(w >= 0.0f && w <= 1.0f);
// Bend the arm 60 degrees at the "elbow": the falloff spreads the bend instead of tearing one row of edges.
auto stretch = [&](float falloff) {
Document d = makeDoc(arm);
CHECK(run(d, "transform", {{"rotate", std::string("0,0,60")}, {"pivot", std::string("0,0,0")}, {"falloff", double(falloff)}}).ok);
float worst = 0.0f;
for (uint32_t v = 0; v < arm.vertexCount(); ++v)
for (uint32_t n : arm.neighbors(v)) {
const float a = glm::length(arm.positions[v] - arm.positions[n]);
const float b = glm::length(d.mesh.positions[v] - d.mesh.positions[n]);
worst = std::max(worst, b / std::max(a, 1e-6f));
}
// The far end turned the whole 60 degrees.
const glm::vec3 tip = d.mesh.positions[size_t(std::max_element(arm.positions.begin(), arm.positions.end(),
[](auto& p, auto& q) { return p.x < q.x; }) -
arm.positions.begin())];
CHECK(std::abs(glm::degrees(std::atan2(tip.y, tip.x)) - 60.0f) < 1.0f);
return worst;
};
const float hardStretch = stretch(0), softStretch = stretch(0.15f);
std::printf(" edge stretch at a 60 degree bend: hard mask %.2fx, falloff 0.15 %.2fx\n", double(hardStretch),
double(softStretch));
// A 60 degree turn eased in over 0.15 of the size still shears the outside of a thick arm (about 2x), but the
// hard mask's tearing step (10x) is gone.
CHECK(softStretch < hardStretch / 3.0f);
}
TEST(transform_hidden_never_moves) {
Document d = makeDoc(makeIcosphere(3));
d.mesh.ensureHidden();
for (uint32_t t = 0; t < d.mesh.triangleCount(); ++t) d.mesh.hidden[t] = d.mesh.positions[d.mesh.triangles[t].x].y > 0.0f;
const auto before = d.mesh.positions;
CHECK(run(d, "transform", {{"translate", std::string("0,0,1")}}).ok);
bool ok = true;
for (uint32_t v = 0; v < d.mesh.vertexCount(); ++v)
if (d.mesh.vertexHidden(v)) ok = ok && d.mesh.positions[v] == before[v];
CHECK(ok);
}
TEST(transform_sculpt_layers_move_with_the_surface) {
Document d = makeDoc(makeIcosphere(3));
Mesh& m = d.mesh;
m.addLayer("Bump");
for (uint32_t v = 0; v < m.vertexCount(); ++v) m.layers[0].delta[v] = m.normals[v] * 0.1f * float(v % 3);
m.setLayerWeight(0, 0.7f);
const auto pos = m.positions, base = m.base, delta = m.layers[0].delta;
CHECK(run(d, "transform", {{"rotate", std::string("0,0,90")}, {"translate", std::string("1,0,0")}, {"pivot", std::string("origin")}}).ok);
auto rot = [](const glm::vec3& p) { return glm::vec3(-p.y, p.x, p.z); };
float err = 0.0f;
for (size_t v = 0; v < pos.size(); ++v) err = std::max(err, glm::length(m.positions[v] - (rot(pos[v]) + glm::vec3(1, 0, 0))));
CHECK(err < 1e-5f);
// The layer still works: at weight 0 it's the transformed base.
m.setLayerWeight(0, 0.0f);
err = 0.0f;
for (size_t v = 0; v < pos.size(); ++v) err = std::max(err, glm::length(m.positions[v] - (rot(base[v]) + glm::vec3(1, 0, 0))));
CHECK(err < 1e-5f);
m.setLayerWeight(0, 0.7f);
CHECK(run(d, "undo").ok);
CHECK(sameBits(m.base, base));
CHECK(sameBits(m.layers[0].delta, delta));
}
// GitHub #133: with a sculpt layer active, Move / Scale / Rotate record into that layer like a stroke (masked or
// not): the base and other layers stay, the layer's weight dials the move in and out, undo restores it.
TEST(transform_records_into_the_active_layer) {
Document d = makeDoc(makeArm());
Mesh& m = d.mesh;
CHECK(run(d, "layer_add", {{"name", std::string("Other")}}).ok);
for (uint32_t v = 0; v < m.vertexCount(); ++v) m.layers[0].delta[v] = m.normals[v] * 0.05f;
m.setLayerWeight(0, 0.5f);
CHECK(run(d, "layer_add", {{"name", std::string("Pose")}}).ok);
CHECK(d.activeLayer == 1);
const auto pos = m.positions, base = m.base, other = m.layers[0].delta;
// Unmasked rotate: the whole Part turns, all of it in the active layer.
CHECK(run(d, "transform", {{"rotate", std::string("0,0,90")}, {"pivot", std::string("origin")}}).ok);
auto rot = [](const glm::vec3& p) { return glm::vec3(-p.y, p.x, p.z); };
float err = 0.0f;
for (size_t v = 0; v < pos.size(); ++v) err = std::max(err, glm::length(m.positions[v] - rot(pos[v])));
CHECK(err < 1e-5f);
CHECK(sameBits(m.base, base));
CHECK(sameBits(m.layers[0].delta, other));
m.setLayerWeight(1, 0.0f); // the layer off: the shape as before
CHECK(maxDistance(m.positions, pos) < 1e-5f);
m.setLayerWeight(1, 0.5f); // half: halfway along each vertex's move
err = 0.0f;
for (size_t v = 0; v < pos.size(); ++v) err = std::max(err, glm::length(m.positions[v] - glm::mix(pos[v], rot(pos[v]), 0.5f)));
CHECK(err < 1e-5f);
m.setLayerWeight(1, 1.0f);
CHECK(run(d, "undo").ok);
CHECK(maxDistance(m.positions, pos) < 1e-6f);
for (const glm::vec3& o : m.layers[1].delta) CHECK(o == glm::vec3(0.0f));
// Masked (the issue: mask, invert, move): only the unmasked part moves, into the layer, at the layer's weight.
maskBelowX(m, 0.0f);
m.setLayerWeight(1, 0.25f);
const auto pos2 = m.positions;
CHECK(run(d, "transform", {{"translate", std::string("0,1,0")}}).ok);
bool still = true, full = true;
for (size_t v = 0; v < pos2.size(); ++v) {
if (m.mask[v] >= 1.0f) still = still && m.positions[v] == pos2[v];
else full = full && glm::length(m.positions[v] - (pos2[v] + glm::vec3(0, 1, 0))) < 1e-5f;
}
CHECK(still);
CHECK(full);
CHECK(sameBits(m.base, base));
m.setLayerWeight(1, 0.0f);
float e2 = 0.0f; // the layer off: base + the other layer at 0.5
for (size_t v = 0; v < base.size(); ++v) e2 = std::max(e2, glm::length(m.positions[v] - (base[v] + 0.5f * other[v])));
CHECK(e2 < 1e-5f);
m.setLayerWeight(1, 0.25f);
CHECK(run(d, "undo").ok);
CHECK(maxDistance(m.positions, pos2) < 1e-6f);
// Weight 0: refused, like a stroke.
m.setLayerWeight(1, 0.0f);
const auto off = m.positions;
CHECK(!run(d, "transform", {{"translate", std::string("0,1,0")}}).ok);
CHECK(sameBits(m.positions, off));
// Base mesh active: the old behaviour (the base and every layer move).
m.setLayerWeight(1, 1.0f);
CHECK(run(d, "layer_set_active", {{"index", -1.0}}).ok);
CHECK(run(d, "transform", {{"translate", std::string("0,1,0")}, {"masked", false}}).ok);
CHECK(m.base[0] == base[0] + glm::vec3(0, 1, 0));
}
// The gizmo's path: a TransformSession recording into a layer, dragged (applied many times), cancelled, finished.
TEST(transform_session_into_a_layer) {
Document d = makeDoc(makeIcosphere(3));
Mesh& m = d.mesh;
m.addLayer("Pose");
m.setLayerWeight(0, 0.5f);
d.syncBvh();
const auto pos = m.positions, base = m.base;
TransformSession s;
CHECK(s.begin(m, {}, Symmetry{false, false, false}, glm::vec3(0.0f), 0));
MeshTransform t;
for (int k = 1; k <= 10; ++k) {
t.rotate = eulerRotation(glm::vec3(0, 0, 9.0f * float(k)));
t.scale = glm::vec3(1.0f + 0.05f * float(k));
s.apply(m, t);
}
s.restore(m);
CHECK(maxDistance(m.positions, pos) < 1e-6f);
s.apply(m, t);
float err = 0.0f;
for (size_t v = 0; v < pos.size(); ++v) err = std::max(err, glm::length(m.positions[v] - t.apply(pos[v])));
CHECK(err < 1e-4f);
CHECK(sameBits(m.base, base));
UndoRecord r = s.finish(m, d.bvh, "Gizmo Rotate");
CHECK(r.layer == 0 && r.layerOffsets.empty());
d.undo.push(std::move(r));
CHECK(run(d, "undo").ok);
CHECK(maxDistance(m.positions, pos) < 1e-6f);
// Weight 0: nothing to do.
m.setLayerWeight(0, 0.0f);
CHECK(!s.begin(m, {}, Symmetry{false, false, false}, glm::vec3(0.0f), 0));
CHECK(TransformSession::layerWeightZero(m, 0));
}
TEST(transform_leaves_topology_and_attributes) {
Document d = makeDoc(makeCube(6));
Mesh& m = d.mesh;
m.uvs.resize(m.triangleCount() * 3);
for (size_t i = 0; i < m.uvs.size(); ++i) m.uvs[i] = glm::vec2(float(i % 7) / 7.0f, float(i % 5) / 5.0f);
m.ensureColors(glm::vec3(0.2f, 0.4f, 0.6f));
const auto tris = m.triangles;
const auto uvs = m.uvs;
const auto quads = m.quadPartners;
const auto groups = m.facegroups;
const auto colors = m.colors;
CHECK(m.quadCount() > 0);
CHECK(run(d, "transform", {{"rotate", std::string("15,25,35")}, {"scale", 1.3}}).ok);
CHECK(m.triangles == tris);
CHECK(sameBits(m.uvs, uvs));
CHECK(m.quadPartners == quads);
CHECK(m.facegroups == groups);
CHECK(sameBits(m.colors, colors));
}
TEST(transform_symmetry_mirrors_a_masked_pose) {
// A bar along X with both ends free: rotating the right end at x=1 with X symmetry turns the left end the
// mirrored way, so the result stays symmetric.
Mesh bar = makeArm(4);
bar.ensureMask();
for (uint32_t v = 0; v < bar.vertexCount(); ++v) bar.mask[v] = std::abs(bar.positions[v].x) < 1.0f ? 1.0f : 0.0f;
Document d = makeDoc(bar);
CHECK(run(d, "transform", {{"rotate", std::string("0,0,30")}, {"pivot", std::string("1,0,0")}, {"symmetry", std::string("x")}}).ok);
// Every vertex's mirror image (found on the original) ended up mirrored.
float err = 0.0f;
int pairs = 0;
for (uint32_t v = 0; v < bar.vertexCount(); ++v) {
const glm::vec3 p = bar.positions[v];
if (p.x <= 1.0f) continue;
for (uint32_t u = 0; u < bar.vertexCount(); ++u) {
const glm::vec3 q = bar.positions[u];
if (glm::length(q - glm::vec3(-p.x, p.y, p.z)) > 1e-4f) continue;
const glm::vec3 a = d.mesh.positions[v], b = d.mesh.positions[u];
err = std::max(err, glm::length(a - glm::vec3(-b.x, b.y, b.z)));
++pairs;
break;
}
}
CHECK(pairs > 10);
CHECK(err < 1e-4f);
// The right end went up, so the left one did too.
CHECK(d.mesh.bounds().max.y > bar.bounds().max.y + 0.2f);
}
TEST(transform_all_parts) {
Document d = makeDoc(makeIcosphere(2));
d.addPart(makeCube(4), "Box", false);
const auto a = d.partMesh(0).positions, b = d.partMesh(1).positions;
CHECK(run(d, "transform", {{"translate", std::string("0,2,0")}, {"all", true}}).ok);
CHECK(d.partMesh(0).positions[0] == a[0] + glm::vec3(0, 2, 0));
CHECK(d.partMesh(1).positions[0] == b[0] + glm::vec3(0, 2, 0));
// One undo step in each Part.
CHECK(d.undo.canUndo());
CHECK(d.parts[1].data->undo.canUndo());
d.selectPart(1);
CHECK(run(d, "undo").ok);
CHECK(sameBits(d.mesh.positions, b));
// Without all=1 only the active one moves.
CHECK(run(d, "transform", {{"translate", std::string("1,0,0")}}).ok);
CHECK(d.partMesh(0).positions[0] == a[0] + glm::vec3(0, 2, 0));
}
TEST(transform_session_never_accumulates) {
// A drag applies many transforms to the same originals; the end result equals one direct transform.
Mesh arm = makeArm(4);
maskBelowX(arm, 0.0f);
Document a = makeDoc(arm), b = makeDoc(arm);
MeshTransform t;
t.pivot = glm::vec3(0.0f);
TransformSession s;
const auto w = transformWeights(a.mesh, true, 0.1f);
CHECK(s.begin(a.mesh, w, Symmetry{false, false, false}, t.pivot));
for (int i = 1; i <= 40; ++i) {
t.rotate = glm::angleAxis(glm::radians(float(i) * 2.0f), glm::vec3(0, 0, 1));
t.translate = glm::vec3(0.01f * float(i), 0, 0);
s.apply(a.mesh, t);
}
a.undo.push(s.finish(a.mesh, a.bvh, "Rotate"));
CHECK(transformPart(b, 0, t, true, 0.1f, Symmetry{false, false, false}, "Rotate") > 0);
CHECK(sameBits(a.mesh.positions, b.mesh.positions));
CHECK(maxDistance(a.mesh.normals, b.mesh.normals) < 1e-5f);
// An identity drag (click without moving) leaves no undo step and no change.
Document c = makeDoc(arm);
TransformSession idle;
CHECK(idle.begin(c.mesh, {}, Symmetry{}, glm::vec3(0.0f)));
idle.apply(c.mesh, MeshTransform{});
CHECK(idle.finish(c.mesh, c.bvh, "Move").empty());
CHECK(sameBits(c.mesh.positions, arm.positions));
}
TEST(transform_bvh_follows) {
Document d = makeDoc(makeIcosphere(3));
CHECK(run(d, "transform", {{"translate", std::string("10,0,0")}}).ok);
RayHit hit;
CHECK(d.bvh.raycast(d.mesh, glm::vec3(10, 0, 5), glm::vec3(0, 0, -1), hit));
CHECK(std::abs(hit.position.z - 1.0f) < 0.05f);
CHECK(!d.bvh.raycast(d.mesh, glm::vec3(0, 0, 5), glm::vec3(0, 0, -1), hit));
CHECK(run(d, "undo").ok);
CHECK(d.bvh.raycast(d.mesh, glm::vec3(0, 0, 5), glm::vec3(0, 0, -1), hit));
}
TEST(transform_command_errors) {
Document d = makeDoc(makeIcosphere(2));
CHECK(!run(d, "transform", {{"scale", 0.0}}).ok);
CHECK(!run(d, "transform", {{"scale", std::string("1,-1,1")}}).ok);
CHECK(!run(d, "transform", {{"pivot", std::string("nowhere")}, {"translate", std::string("1,0,0")}}).ok);
CHECK(!run(d, "transform", {{"translate", std::string("1,0")}}).ok);
CHECK(!run(d, "transform", {{"symmetry", std::string("w")}, {"translate", std::string("1,0,0")}}).ok);
CHECK(run(d, "transform").ok); // nothing to do is fine
CHECK(!d.undo.canUndo());
}
TEST(transform_euler_round_trip) {
for (const glm::vec3 e : {glm::vec3(10, 20, 30), glm::vec3(-45, 80, 170), glm::vec3(0, 0, -90)}) {
const glm::vec3 back = eulerDegrees(eulerRotation(e));
CHECK(glm::length(back - e) < 1e-2f);
}
}
TEST(transform_perf_million_triangles) {
// 1.3M triangles: a whole-Part drag frame and a masked (posing) drag frame, plus begin / finish.
Mesh m = makeIcosphere(8);
maskBelowX(m, 0.3f);
Document d = makeDoc(std::move(m));
using clock = std::chrono::steady_clock;
auto ms = [](clock::time_point a) { return std::chrono::duration<double, std::milli>(clock::now() - a).count(); };
for (int masked = 0; masked < 2; ++masked) {
auto t0 = clock::now();
const auto w = transformWeights(d.mesh, masked != 0, masked ? 0.1f : 0.0f);
TransformSession s;
CHECK(s.begin(d.mesh, w, Symmetry{}, transformCenter(d.mesh, w)));
const double begin = ms(t0);
MeshTransform t;
t.pivot = transformCenter(d.mesh, w);
t0 = clock::now();
const int frames = 10;
for (int i = 1; i <= frames; ++i) {
t.rotate = glm::angleAxis(glm::radians(float(i)), glm::vec3(0, 1, 0));
s.apply(d.mesh, t);
}
const double frame = ms(t0) / frames;
const size_t moving = s.movingVertices();
t0 = clock::now();
d.undo.push(s.finish(d.mesh, d.bvh, "Rotate"));
const double finish = ms(t0);
t0 = clock::now();
CHECK(run(d, "undo").ok);
const double undo = ms(t0);
std::printf(" %zu tris, %s: begin %.1f ms, %.1f ms per drag frame (%zu verts), finish %.1f ms, undo %.1f ms\n",
d.mesh.triangleCount(), masked ? "masked + falloff 0.1" : "whole Part", begin, frame,
moving, finish, undo);
}
}
TEST(transform_saved_in_projects) {
// A posed Part with a sculpt layer and quads saves and opens as it is.
Document d = makeDoc(makeCube(6));
d.mesh.addLayer("Detail");
for (uint32_t v = 0; v < d.mesh.vertexCount(); ++v) d.mesh.layers[0].delta[v] = d.mesh.normals[v] * 0.05f;
d.mesh.setLayerWeight(0, 1.0f);
maskBelowX(d.mesh, 0.0f);
CHECK(run(d, "transform", {{"rotate", std::string("0,0,45")}, {"pivot", std::string("0,0,0")}, {"falloff", 0.2}}).ok);
const std::string path = tempPath("sf_transform_test.sfproj");
std::string err;
CHECK(saveProject(path, d, err));
Document e;
CHECK(loadProject(path, e, err));
CHECK(sameBits(e.mesh.positions, d.mesh.positions));
CHECK(sameBits(e.mesh.base, d.mesh.base));
CHECK(e.mesh.layers.size() == 1 && sameBits(e.mesh.layers[0].delta, d.mesh.layers[0].delta));
CHECK(e.mesh.quadPartners == d.mesh.quadPartners);
std::filesystem::remove(path);
}