Skip to content

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.

Predictive strokes on by default: the surface cursor no longer races the solver thread (the cause of strokes differing from the serial path); draft strokes no longer chosen by tier or battery; ui_stroke_resize re-enabled; verify reports positions and normals separately

islandmed2e424c9ce703
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8957d7da..dce52971 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,17 @@ All notable changes to SculptForge are listed here. The format follows
## [Unreleased]
+### Changed
+- **Predictive strokes are on by default**: big brushes on dense meshes keep up with the pen (21M triangles: frames
+ about 9 ms instead of 70, the brush 1-2 px behind the pointer instead of 40, no pause when you lift the pen). The
+ result is identical, bit for bit, to a stroke placed without them (checked by `ui_stroke_resize`).
+- Draft strokes are no longer chosen by any hardware tier or on battery (they measured no faster and aren't yet
+ identical to a full stroke); the Draft Strokes setting still turns them on.
+
+### Fixed
+- The brush ring that follows the surface (#25) read the mesh while a predictive stroke's thread was changing it,
+ which could change where that stroke's dabs landed; it now shows the flat ring during such strokes.
+
## [0.10.1] - 2026-11-01
0.10.0 was tagged but never published (its Windows build failed); everything in it ships here.
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8d633f14..aafaf69b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -594,7 +594,7 @@ if(SCULPTFORGE_BUILD_TESTS)
# was handed (no data race with the solver thread), replaying the stroke without the thread gives the same
# mesh, bit for bit, and its undo the mesh it started from.
add_test(NAME ui_stroke_resize COMMAND sculptforge --run "new_sphere" --measure-stroke 1.5)
- set_tests_properties(ui_stroke_resize PROPERTIES LABELS ui TIMEOUT 60 DISABLED TRUE # predictive strokes are experimental in 0.10: not yet bit-identical to the serial path
+ set_tests_properties(ui_stroke_resize PROPERTIES LABELS ui TIMEOUT 60
ENVIRONMENT "SF_NO_UPDATE_CHECK=1;SF_MEASURE_RESIZE=1;SF_MEASURE_VERIFY=1;SF_PREDICTIVE_STROKE=1")
# The guide's keyboard table must match the app's default shortcuts (tools/guide/update_shortcuts.py).
if(Python3_Interpreter_FOUND)
diff --git a/docs/guide/performance.md b/docs/guide/performance.md
index 72906a06..5df6f024 100644
--- a/docs/guide/performance.md
+++ b/docs/guide/performance.md
@@ -60,7 +60,7 @@ There are two main profiles and a safe mode:
| **Workstation** | 64 GB of memory or more, and a graphics card with 16 GB or more or an Apple Silicon Max / Ultra (or another chip whose graphics share the memory) that measures as fast | more triangles drawn per frame, larger textures and subdivision limits, shading updated with every dab |
| **Software** (safe mode) | no graphics driver, so the drawing happens on the processor (llvmpipe) | the lightest settings, no antialiasing |
-On a laptop running on battery, whatever its profile, SculptForge switches to draft brushes, sends less data to the graphics card per
+On a laptop running on battery, whatever its profile, SculptForge sends less data to the graphics card per
frame and aims for 60 frames a second, and the status bar says so; plugged in again, it goes back.
At the top of **Preferences > Performance**:
diff --git a/docs/performance.md b/docs/performance.md
index 27558221..bdf716c7 100644
--- a/docs/performance.md
+++ b/docs/performance.md
@@ -297,12 +297,12 @@ changes when it does):
| `residentCacheCapMB` | RAM / 8, at most 1 GB | RAM / 4, at most 4 GB | RAM x 2/5, at most 64 GB |
| `activeTriangleBudget` | 0.5M | 2M | 8M+ (half the render budget, at most 64M) |
| `uploadBudgetMBPerFrame` | the profile's | the profile's | the profile's |
-| `draftBrushMode` (normals and cavity at pen release) | on | off (on battery: on) | off (on battery: on) |
+| `draftBrushMode` (normals and cavity at pen release) | off | off | off (the Draft Strokes setting turns them on) |
| `zeroCopyUMA` | the GPU shares system memory: unified or integrated, in any tier (a 64 GB+ Apple Silicon Workstation too) | | |
| `targetHz` | 60 | 60 / 120 / 144 from the display | 60 / 120 / 144 from the display |
The app reads the power source with `SDL_GetPowerInfo` at start and every 5 seconds. On battery, whatever the tier
-(an Apple Silicon Workstation is a laptop too): draft brushes,
+(an Apple Silicon Workstation is a laptop too): no draft brushes (they are a manual setting),
half the upload budget and 60 Hz (unless set by hand), and the status bar says so. The `draft_brush` override
(on / off) wins over both. `draftBrushMode` is a flag for the brush engine; the brushes don't read it yet.
diff --git a/src/app/App.cpp b/src/app/App.cpp
index 7dd4e7c6..ba27b1a9 100644
--- a/src/app/App.cpp
+++ b/src/app/App.cpp
@@ -2853,6 +2853,8 @@ bool App::drawSurfaceCursor(ImDrawList* dl, float radiusPx, ImU32 col) {
// Only what brushes work on: the active, visible SubTool with an up-to-date BVH (a stale one, after a
// whole-mesh change, is rebuilt at the next press; until then the flat ring shows), not an LOD preview.
if (previewLod_ >= 0 || doc_.bvhDirty) return false;
+ // Not while the solver thread is moving this mesh (predictive strokes): reading it then races the dabs.
+ if (solverBusy() || (asyncStroke_ && drag_ == Drag::Stroke)) return false;
RayHit hit;
if (!pick(mouseX_, mouseY_, hit)) return false; // one ray, as a press would cast
// The world radius a dab here gets (App::firstDab / the brushes: Draw Size times world size of a pixel).
diff --git a/src/app/AsyncStroke.cpp b/src/app/AsyncStroke.cpp
index 9a1c5535..b8745e99 100644
--- a/src/app/AsyncStroke.cpp
+++ b/src/app/AsyncStroke.cpp
@@ -452,8 +452,17 @@ uint64_t App::meshStateHash(const Mesh& mesh) {
return h;
}
+static uint64_t positionsHash(const Mesh& mesh) {
+ uint64_t h = 1469598103934665603ull;
+ const auto* p = reinterpret_cast<const uint8_t*>(mesh.positions.data());
+ for (size_t i = 0; i < mesh.positions.size() * sizeof(glm::vec3); ++i) h = (h ^ p[i]) * 1099511628211ull;
+ return h;
+}
+
bool App::verifyStroke(uint64_t before, const std::vector<glm::vec2>& dabs, const std::vector<float>& radii) {
const uint64_t after = meshStateHash(doc_.mesh);
+ const uint64_t afterPositions = positionsHash(doc_.mesh);
+ const std::vector<glm::vec3> afterNormals = doc_.mesh.normals;
runCommand("undo", {});
const uint64_t undone = meshStateHash(doc_.mesh);
const bool undoOk = undone == before;
@@ -477,6 +486,16 @@ bool App::verifyStroke(uint64_t before, const std::vector<glm::vec2>& dabs, cons
return meshStateHash(doc_.mesh);
};
const uint64_t replay = place();
+ const bool samePositions = positionsHash(doc_.mesh) == afterPositions;
+ size_t normalDiffs = 0;
+ float maxNormalDiff = 0.0f;
+ for (size_t i = 0; i < afterNormals.size() && i < doc_.mesh.normals.size(); ++i)
+ if (afterNormals[i] != doc_.mesh.normals[i]) {
+ ++normalDiffs;
+ maxNormalDiff = std::max(maxNormalDiff, glm::length(afterNormals[i] - doc_.mesh.normals[i]));
+ }
+ std::printf("verify: positions %s; %zu normals differ (largest %.3g)\n", samePositions ? "identical" : "DIFFERENT",
+ normalDiffs, double(maxNormalDiff));
// And once more: the frame-loop path against itself (anything here that isn't deterministic shows).
runCommand("undo", {});
const uint64_t again = place();
diff --git a/src/app/Config.h b/src/app/Config.h
index c028575a..bdedb2ce 100644
--- a/src/app/Config.h
+++ b/src/app/Config.h
@@ -45,7 +45,7 @@ struct UiPrefs {
bool multithreading = true; // brushes, normals and BVH updates on every core (off: one thread)
// Sculpt strokes solved on their own thread with a GPU preview of the dabs still to come, the cursor and the
// stroke's head predicted a frame ahead (app/AsyncStroke.cpp). Off: the dabs are placed in the frame loop.
- bool predictiveStrokes = false; // experimental in 0.10 (Preferences > Performance)
+ bool predictiveStrokes = true;
// Draft strokes (with predictive strokes): dabs move the vertices only; the normals, cavities and culling
// bounds of what they touched are worked out once, when the pen lifts (Sculptor::draftStrokes). Off by
// default; meant for laptops and battery (a hardware tier will turn it on).
diff --git a/src/app/PanelPerformanceProfile.cpp b/src/app/PanelPerformanceProfile.cpp
index 0e00c4f5..a3a75be9 100644
--- a/src/app/PanelPerformanceProfile.cpp
+++ b/src/app/PanelPerformanceProfile.cpp
@@ -79,7 +79,7 @@ bool calibrationDisabled() {
return v && *v && *v != '0';
}
-// Battery or mains (SDL_GetPowerInfo): a laptop on battery drops to draft brushes and 60 Hz (core/TierConfig.h).
+// Battery or mains (SDL_GetPowerInfo): a laptop on battery sends less per frame and drops to 60 Hz (core/TierConfig.h).
PowerSource powerSource() {
switch (SDL_GetPowerInfo(nullptr, nullptr)) {
case SDL_POWERSTATE_ON_BATTERY: return PowerSource::Battery;
@@ -263,7 +263,7 @@ void App::hardwareProfileFrameEnd() {
const HardwareProfile p = hw.profile;
applyHardwareProfile(p, false);
if (battery != wasBattery)
- status_ = battery ? "On battery: draft brushes (normals and cavity at pen release), " + std::to_string(hw.tier.targetHz) + " Hz"
+ status_ = battery ? "On battery: lighter uploads, " + std::to_string(hw.tier.targetHz) + " Hz"
: "On mains power: " + std::string(hw.tier.draftBrushMode ? "draft" : "continuous") + " brushes, " +
std::to_string(hw.tier.targetHz) + " Hz";
}
diff --git a/src/core/TierConfig.cpp b/src/core/TierConfig.cpp
index 5bb403d6..d3398eb2 100644
--- a/src/core/TierConfig.cpp
+++ b/src/core/TierConfig.cpp
@@ -45,14 +45,14 @@ TierConfig tierConfigFor(const HardwareProfile& p, PowerSource power, int displa
}
c.uploadBudgetMBPerFrame = std::max<uint64_t>(s.uploadBudgetMBPerFrame, 4);
c.zeroCopyUMA = p.hardware.gpuKind == GpuKind::Unified || p.hardware.gpuKind == GpuKind::Integrated;
- // Draft brushes only where they save work: Software, and on battery (below). Measured on a Laptop-tier M1 Pro at
- // 33M they were no faster (frames are GPU-bound) and the last dab landed later after release.
- c.draftBrushMode = p.tier == ProfileTier::Software;
+ // Draft brushes are not chosen by any tier: measured on a Laptop-tier M1 Pro at 33M they were no faster (frames
+ // are GPU-bound), the last dab landed later, and a draft stroke isn't yet identical to a full one. The override
+ // (Preferences) still turns them on.
+ c.draftBrushMode = false;
c.targetHz = p.overrides.targetFps ? p.overrides.targetFps : targetHzForDisplay(displayHz);
if (p.tier == ProfileTier::Software) c.targetHz = std::min(c.targetHz, 60);
if (c.onBattery()) {
- // On battery: less heat and power. Draft brushes, half the uploads, 60 Hz (unless set by hand).
- c.draftBrushMode = true;
+ // On battery: less heat and power. Half the uploads, 60 Hz (unless set by hand).
c.uploadBudgetMBPerFrame = std::max<uint64_t>(c.uploadBudgetMBPerFrame / 2, 4);
if (!p.overrides.targetFps) c.targetHz = 60;
}
diff --git a/tests/test_hardware_profile.cpp b/tests/test_hardware_profile.cpp
index b6b64fe1..acbc7afb 100644
--- a/tests/test_hardware_profile.cpp
+++ b/tests/test_hardware_profile.cpp
@@ -703,7 +703,7 @@ TEST(hw_tier_config) {
// On battery: draft brushes, half the uploads, 60 Hz.
const TierConfig b = tierConfigFor(ws, PowerSource::Battery, 144);
CHECK(b.onBattery());
- CHECK(b.draftBrushMode);
+ CHECK(!b.draftBrushMode); // no tier picks draft brushes, battery included
CHECK(b.targetHz == 60);
CHECK(b.uploadBudgetMBPerFrame == std::max<uint64_t>(c.uploadBudgetMBPerFrame / 2, 4));
// Overrides win: draft never, a fixed target.
@@ -720,7 +720,7 @@ TEST(hw_tier_config) {
CHECK(tierConfigFor(mac, PowerSource::AC, 120).zeroCopyUMA);
CHECK(tierConfigFor(mac, PowerSource::AC, 120).targetHz == 120);
CHECK(!tierConfigFor(mac, PowerSource::AC, 120).draftBrushMode);
- CHECK(tierConfigFor(mac, PowerSource::Battery, 120).draftBrushMode);
+ CHECK(!tierConfigFor(mac, PowerSource::Battery, 120).draftBrushMode);
CHECK(tierConfigFor(mac, PowerSource::Battery, 120).zeroCopyUMA);
CHECK(tierConfigFor(mac, PowerSource::Battery, 120).targetHz == 60);
// Software: safe mode at 60 Hz at most.
diff --git a/tests/ui/performance.sfui b/tests/ui/performance.sfui
index 9daf8ea9..a9d7277e 100644
--- a/tests/ui/performance.sfui
+++ b/tests/ui/performance.sfui
@@ -22,13 +22,13 @@ hover "Predictive Strokes"
expect_help "exactly the same"
hold none
-# Predictive Strokes: off by default (experimental in 0.10), on and off again.
-expect_value predictive_strokes == 0
-click "Predictive Strokes"
+# Predictive Strokes: on by default, off and on again.
expect_value predictive_strokes == 1
click "Predictive Strokes"
expect_value predictive_strokes == 0
expect_status "Predictive strokes off"
+click "Predictive Strokes"
+expect_value predictive_strokes == 1
# Antialiasing off and back; 8x.
click "AA Off##perf.aa_1"