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
#include "core/TierConfig.h"
#include <algorithm>
#include <atomic>
#include <mutex>
namespace sf {
const char* powerSourceName(PowerSource power) {
switch (power) {
case PowerSource::AC: return "ac";
case PowerSource::Battery: return "battery";
case PowerSource::Unknown: break;
}
return "unknown";
}
size_t strokeShadeBudget(size_t points, double ms, double nsPerPoint, size_t minPoints) {
if (!(ms > 0.0) || !(nsPerPoint > 0.0)) return points;
const size_t timed = std::max(size_t(ms * 1e6 / nsPerPoint), minPoints);
return points ? std::min(points, timed) : timed;
}
size_t microShadeBudget(const TierConfig& tier, bool stroking, bool viewMoving, double nsPerPoint, size_t minPoints) {
const size_t points = size_t(tier.shadeBudgetPoints) / (stroking && tier.draftBrushMode ? 4 : 1);
return stroking || viewMoving ? strokeShadeBudget(points, tier.strokeShadeMs, nsPerPoint, minPoints) : points;
}
int targetHzForDisplay(int hz) {
if (hz >= 143) return 144;
if (hz >= 119) return 120;
return 60;
}
TierConfig tierConfigFor(const HardwareProfile& p, PowerSource power, int displayHz, int memoryStepDown) {
TierConfig c;
c.tier = p.tier;
c.power = power;
const uint64_t ram = p.hardware.ramMB ? p.hardware.ramMB : 8192;
const PerformanceSettings& s = p.settings;
switch (p.tier) {
case ProfileTier::Software:
c.residentCacheCapMB = std::clamp<uint64_t>(ram / 8, 256, 1024);
c.activeTriangleBudget = 500'000;
break;
case ProfileTier::Laptop:
c.residentCacheCapMB = std::clamp<uint64_t>(ram / 4, 512, 4096);
c.activeTriangleBudget = 2'000'000;
break;
case ProfileTier::Workstation:
c.residentCacheCapMB = std::clamp<uint64_t>(ram * 2 / 5, 4096, 65536);
c.activeTriangleBudget = std::clamp<uint64_t>(s.renderTriangleBudget / 2, 8'000'000, 64'000'000);
break;
}
c.uploadBudgetMBPerFrame = std::max<uint64_t>(s.uploadBudgetMBPerFrame, 4);
c.zeroCopyUMA = p.hardware.gpuKind == GpuKind::Unified || p.hardware.gpuKind == GpuKind::Integrated;
// 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. 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;
}
// Micro levels: shading per frame by tier; out of core once a level's tiles (2 bytes a point) would pass the
// resident cache.
c.shadeBudgetPoints = p.tier == ProfileTier::Workstation ? (3u << 20) : p.tier == ProfileTier::Laptop ? (1u << 20) : (1u << 19);
c.outOfCorePoints = (c.residentCacheCapMB << 20) / 2;
if (p.overrides.draftBrush == 1) c.draftBrushMode = true;
else if (p.overrides.draftBrush == 2) c.draftBrushMode = false;
// The hardware tier's budgets, stepped down by the memory guard.
c.chosenHwTier = p.hwTier;
c.memoryStepDown = std::clamp(memoryStepDown, 0, int(p.hwTier));
c.hwTier = HwTier(int(p.hwTier) - c.memoryStepDown);
c.budgets = budgetsForTier(c.hwTier);
// Focus Detail's GPU pool on a small graphics card: 256 MB under a 1.5 GB video memory budget.
if (c.hwTier == HwTier::Floor && s.vramBudgetMB && s.vramBudgetMB < 1536) c.budgets.focusGpuPoolMB = 256;
c.budgets.maxTextureSize = s.maxTextureSize;
c.budgets.threads = s.threads; // (SF_HW_SIMULATE=floor: the app sets 4)
applyTierBudgetEnv(c.budgets);
ComputeChoice saved = ComputeChoice::Auto;
computeChoiceFromName(p.overrides.compute, saved);
c.compute = computeChoiceWithEnv(saved);
c.turbo = p.overrides.turbo;
return c;
}
Json tierConfigJson(const TierConfig& c) {
Json j = Json::object();
j.set("tier", tierName(c.tier));
j.set("resident_cache_cap_mb", double(c.residentCacheCapMB));
j.set("active_triangle_budget", double(c.activeTriangleBudget));
j.set("shade_budget_points", double(c.shadeBudgetPoints));
j.set("stroke_shade_ms", c.strokeShadeMs);
j.set("out_of_core_points", double(c.outOfCorePoints));
j.set("upload_budget_mb_per_frame", double(c.uploadBudgetMBPerFrame));
j.set("draft_brush_mode", c.draftBrushMode);
j.set("zero_copy_uma", c.zeroCopyUMA);
j.set("target_hz", c.targetHz);
j.set("power", powerSourceName(c.power));
j.set("on_battery", c.onBattery());
j.set("hw_tier", hwTierName(c.hwTier));
j.set("chosen_hw_tier", hwTierName(c.chosenHwTier));
j.set("memory_step_down", c.memoryStepDown);
j.set("budgets", tierBudgetsJson(c.budgets));
j.set("compute", computeChoiceName(c.compute));
j.set("turbo", c.turbo);
return j;
}
namespace {
std::mutex g_mutex;
TierConfig g_config;
std::atomic<uint64_t> g_revision{0};
} // namespace
TierConfig currentTierConfig() {
std::lock_guard<std::mutex> lock(g_mutex);
return g_config;
}
void setCurrentTierConfig(const TierConfig& config) {
{
std::lock_guard<std::mutex> lock(g_mutex);
g_config = config;
}
g_revision.fetch_add(1, std::memory_order_relaxed);
}
uint64_t tierConfigRevision() { return g_revision.load(std::memory_order_relaxed); }
} // namespace sf