Write HTML. Render video. Built for agents.
JavaScript aiai-agentsanimationclaude-codeffmpegframeworkgsaphtmlhtml-to-videomcpmotion-graphicspuppeteerrenderingtypescriptvideo-editor
// Every tunable in this piece lives here as a DialKit config.
// Baking chosen values = editing the first element of each tuple.
import type { DialConfig } from "dialkit";
const sel = <T extends string>(def: T, options: readonly T[]) => ({
type: "select" as const,
options: options as unknown as string[],
default: def,
});
/** `?lite=1` lowers every heavy default (used for headless technical checks on software WebGPU). */
export const LITE =
typeof location !== "undefined" && new URLSearchParams(location.search).has("lite");
export const presetsDefaults = {
copyAllJson: { type: "action" as const, label: "Copy all params as JSON" },
} satisfies DialConfig;
export const SHAPES = ["torus", "sphere", "roundedBox", "pyramid", "icosahedron", "logo"] as const;
export type ShapeName = (typeof SHAPES)[number];
export const shapeDefaults = {
shape: sel("torus", SHAPES),
size: [1.0, 0.5, 1.6, 0.01],
tubeRatio: [0.45, 0.2, 0.7, 0.005],
deformAmplitude: [0.045, 0, 0.2, 0.001],
deformFrequency: [1.1, 0.3, 4, 0.05],
segments: [256, 64, 512, 8],
seed: [7, 0, 999, 1],
// world-space offset of the object (hero pages override this from their own panel)
offsetX: [0, -5, 5, 0.01],
offsetY: [0, -4, 4, 0.01],
offsetZ: [0, -4, 4, 0.01],
// extrusion of /public/logo.svg when shape = logo (fractions are relative to `logo.width`)
logo: {
_collapsed: true,
width: [2.6, 0.8, 5, 0.05],
depth: [0.22, 0.02, 1, 0.005],
bevelThickness: [0.06, 0, 0.3, 0.002],
bevelSize: [0.05, 0, 0.3, 0.002],
bevelOffset: [0, -0.1, 0.1, 0.002],
bevelSegments: [5, 1, 16, 1],
cornerRadius: [0.03, 0, 0.15, 0.001],
curveSegments: [24, 2, 64, 1],
creaseAngle: [40, 0, 180, 1],
sdfRes: [64, 32, 128, 8],
},
} satisfies DialConfig;
export const iceDefaults = {
ior: [1.36, 1.0, 2.0, 0.005],
dispersion: [0, 0, 0.3, 0.005],
thicknessScale: [1.0, 0.1, 3, 0.01],
attenuationDistance: [0.9, 0.05, 5, 0.01],
attenuationColor: "#cfd2d4",
baseRoughness: [0.05, 0, 0.5, 0.005],
frost: {
scale: [1.6, 0.2, 6, 0.05],
threshold: [0.5, 0, 1, 0.01],
softness: [0.28, 0.01, 1, 0.01],
roughness: [0.65, 0, 1, 0.01],
diffuse: [0.55, 0, 1, 0.01],
crystalBump: [0.12, 0, 1, 0.01],
crystalScale: [28, 4, 80, 1],
},
cracks: {
largeScale: [1.6, 0.3, 8, 0.05],
warp: [0.45, 0, 1.5, 0.01],
warpScale: [1.4, 0.2, 6, 0.05],
coverage: [0.55, 0, 1, 0.01],
regionScale: [0.8, 0.1, 4, 0.05],
regionCoverage: [0.7, 0, 1, 0.01],
veinScale: [5, 1, 20, 0.25],
veinContrast: [0.7, 0, 1, 0.01],
width: [0.004, 0.0005, 0.02, 0.0005],
brightness: [0.4, 0, 3, 0.01],
darkness: [0.5, 0, 1, 0.01],
refraction: [0.02, 0, 0.1, 0.001],
surfaceStrength: [0.35, 0, 1, 0.01],
steps: [14, 4, 32, 1],
fineCracks: true,
fineScale: [5.5, 2, 20, 0.1],
fineAmount: [0.45, 0, 1, 0.01],
fineCoverage: [0.35, 0, 1, 0.01],
fineNearLarge: [0.75, 0, 1, 0.01],
},
smudges: {
amount: [0.6, 0, 1, 0.01],
coverage: [0.55, 0, 1, 0.01],
maskScale: [1.2, 0.1, 6, 0.05],
anisotropy: [6, 1, 20, 0.5],
roughness: [0.35, 0, 1, 0.01],
whiteness: [0.08, 0, 0.5, 0.005],
scale: [3.2, 0.5, 10, 0.1],
},
bumps: {
microBump: [0.25, 0, 1, 0.005],
microScale: [60, 10, 200, 1],
microCoverage: [0.6, 0, 1, 0.01],
rippleBump: [0.3, 0, 1, 0.01],
rippleScale: [9, 2, 30, 0.5],
maskScale: [1.5, 0.1, 6, 0.05],
},
// emissive glow of partially eroded (crumbling) ice along the view ray; the old value was 1 and blew out
crumbleGlow: [0.15, 0, 2, 0.01],
// how much the crumbly edge band around a cut whitens and opacifies the ice (0 = stays glassy)
edgeWhiteness: [0.5, 0, 1, 0.01],
clearcoat: [0.3, 0, 1, 0.01],
clearcoatRoughness: [0.08, 0, 1, 0.005],
envIntensity: [0.55, 0, 3, 0.01],
specularIntensity: [1.0, 0, 2, 0.01],
interiorScatter: [0.25, 0, 1, 0.01],
} satisfies DialConfig;
export const erosionDefaults = {
resolution: sel("128", ["64", "96", "128", "192"] as const),
brushRadius: [0.28, 0.05, 0.8, 0.005],
brushSoftness: [0.5, 0, 1, 0.01],
brushStrength: [2.2, 0.1, 8, 0.05],
brushSpeedRef: [3.0, 0.2, 12, 0.1],
brushNoise: [0.55, 0, 1, 0.01],
brushNoiseScale: [9, 2, 30, 0.5],
throughDepth: [1.0, 0, 1, 0.01],
// ice breaks along cells: the brush is evaluated per break cell (flat facets) and mixed with the smooth capsule
cellSnap: [0.85, 0, 1, 0.01],
breakCellScale: [3.0, 0.5, 8, 0.1],
crumbleRate: [1.6, 0, 6, 0.05],
crumbleCrackBias: [2.5, 0, 6, 0.05],
crumbleDuration: [0.5, 0, 2, 0.01],
// the surface is gone where erosion exceeds cutThreshold (narrow stochastic transition, resolved by TRAA);
// the crumbly edge band sits just below it, edgeWidth wide
cutThreshold: [0.7, 0.3, 0.98, 0.01],
cutSoftness: [0.04, 0.005, 0.3, 0.005],
edgeWidth: [0.35, 0.05, 0.8, 0.01],
// the cut surface seen through a hole: ray-march steps through the field, and extra frost on the fresh break
interiorSteps: [24, 8, 64, 1],
interiorFrost: [0, 0, 1, 0.01],
edgeInset: [0.06, 0, 0.3, 0.005],
edgeBump: [0.6, 0, 2, 0.01],
edgeBumpScale: [55, 10, 160, 1],
} satisfies DialConfig;
export const powderDefaults = {
particleCount: sel("1M", ["100k", "250k", "500k", "1M", "2M"] as const),
// fraction of the eroded volume that becomes visible powder (the rest simply vanishes)
amount: [0.3, 0.02, 1, 0.01],
grainSizeMultiplier: [1.0, 0.2, 4, 0.05],
// where the interior sample points sit: fraction placed within `nearSurfaceDepth` of the surface
nearSurfaceFraction: [0.6, 0, 1, 0.01],
nearSurfaceDepth: [0.2, 0.05, 0.5, 0.01],
grainSizes: {
// four classes, tiny -> large; the ratios are normalised, the leftover ~1% is large fragments
tinyDustRatio: [0.7, 0, 1, 0.01],
smallGrainRatio: [0.22, 0, 1, 0.01],
mediumClumpRatio: [0.07, 0, 1, 0.01],
tinyDustSize: [0.0055, 0.001, 0.03, 0.0005],
smallGrainSize: [0.011, 0.002, 0.05, 0.0005],
mediumClumpSize: [0.022, 0.005, 0.1, 0.001],
largeFragmentSize: [0.05, 0.01, 0.2, 0.001],
sizeJitter: [0.45, 0, 1, 0.01],
},
grainVariants: [5, 1, 6, 1],
// flat-shaded low-poly splinters instead of smooth blobs (each face catches the key light separately)
facetedGrains: false,
// grains never render below this many pixels (sub-pixel dust flickers under TRAA)
minPixelSize: [1.5, 0, 4, 0.05],
ejectSpeed: [1.1, 0, 4, 0.01],
// grains released after the cursor stopped (crumble) still get at least this kick, units/s
minEjectSpeed: [1.0, 0, 4, 0.01],
ejectSpread: [0.5, 0, 3, 0.01],
ejectTurbulence: [0.8, 0, 4, 0.01],
backwardRatio: [0.25, 0, 1, 0.01],
clumpSpeedJitter: [0.5, 0, 1, 0.01],
drag: [1.4, 0, 8, 0.01],
gravity: [0.12, 0, 2, 0.005],
turbulence: [0.9, 0, 4, 0.01],
turbulenceScale: [1.8, 0.2, 8, 0.05],
turbulenceDecay: [0.6, 0.05, 4, 0.01],
clumpCohesion: [2.4, 0, 10, 0.05],
clumpCount: [24000, 500, 100000, 500],
settleTime: [3.2, 0.3, 12, 0.05],
settledDrift: [0.012, 0, 0.1, 0.001],
tumble: [2.5, 0, 12, 0.05],
baseTone: "#dcdcdc",
wrap: [0.45, 0, 1, 0.01],
// ice-shard look of the grains: the backdrop shows through their centres, rims stay bright (Fresnel),
// real specular / clearcoat from the lights, and per-grain sparkle
fragments: {
translucency: [0.6, 0, 1, 0.01],
throughTint: "#aeb6bb",
fresnelPower: [3, 0.5, 8, 0.1],
roughness: [0.32, 0, 1, 0.01],
clearcoat: [0.6, 0, 1, 0.01],
specular: [1.0, 0, 3, 0.01],
sparkle: [0.6, 0, 3, 0.01],
sparkleFraction: [0.35, 0, 1, 0.01],
sparkleSpread: [0.5, 0, 1.5, 0.01],
},
// repulsion from the object: an acceleration away from the surface (full strength inside, smooth
// falloff over repelRange outside), added to the other forces so grains drift out organically
// shard sprites: every grain is a camera-facing quad textured from the shard atlas (16 photographed-looking
// ice shards: silhouette, bevel normal map, frost structure, thickness). Off = the low-poly mesh grains.
sprites: {
enabled: true,
sizeScale: [1.4, 0.3, 4, 0.05],
// random tilt off the camera plane (degrees): 0 = flat billboards, more = thinner, more varied shards
tilt: [30, 0, 70, 1],
normalStrength: [1, 0, 2.5, 0.05],
// how much the atlas' frost structure drives the look (0 = every shard clear glass)
frostFromAtlas: [1, 0, 1, 0.01],
frostBoost: [0.35, 0, 1.5, 0.01],
frostRoughness: [0.7, 0, 1, 0.01],
// key light caught by the thin bevelled rim
edgeLight: [0.6, 0, 3, 0.01],
alphaCut: [0.2, 0.05, 0.6, 0.01],
// real transparency: how much the clear parts of a shard show what is behind them (rebuilds the powder)
seeThrough: [0, 0, 1, 0.01],
},
repelFromObject: false,
repelStrength: [6, 0, 30, 0.1],
repelRange: [0.35, 0.02, 2, 0.01],
// plus a push straight away from the object's centre, so grains never settle in concave pockets of
// the shape (the surface-normal push alone balances out inside a pocket); range in object radii
repelRadial: [12, 0, 60, 0.5],
repelRadialRange: [1.6, 1, 4, 0.05],
// hard cap on grain speed (units/s): repulsion and ejection can never fling a grain off-screen
maxSpeed: [8, 1, 40, 0.1],
// a grain farther than this from the object (world units, far off screen) is brought back to its rest
lostRadius: [30, 5, 100, 1],
densityShadowStrength: [0.75, 0, 2, 0.01],
densityAOStrength: [0.55, 0, 2, 0.01],
densityGrid: sel("64", ["32", "48", "64"] as const),
densityExtent: [4.2, 2, 10, 0.1],
hazeIntensity: [0.22, 0, 1.5, 0.005],
hazeSteps: [28, 8, 64, 1],
inheritRotation: true,
inheritTime: [220, 0, 1500, 10],
strayCount: [40, 0, 200, 1],
straySpeed: [0.06, 0, 0.5, 0.005],
fragmentShadowMap: true,
} satisfies DialConfig;
export const healingDefaults = {
healDelay: [3.5, 0, 12, 0.1],
// a grain also turns back on its own this long after it left (0 = only when the cursor is idle),
// so pieces keep cycling while you keep breaking
returnAfter: [3.0, 0, 20, 0.1],
// grains fly home in a wave: the ones closest to the object first, the far plume last, spread over
// waveTime (a grain waveReach units away waits the full waveTime)
waveTime: [2.0, 0, 8, 0.05],
waveReach: [3.0, 0.2, 10, 0.1],
waveJitter: [0.6, 0, 3, 0.05],
// return motion: 'spring' = a damped spring toward the rest that ramps in while the grain is still
// flying out (continuous decelerate / turn / accelerate back); 'path' = the eased curved path
returnMode: sel("spring", ["spring", "path"] as const),
returnSpring: [6, 0.5, 40, 0.1],
returnDamping: [0.9, 0.2, 2, 0.01],
returnRamp: [0.6, 0, 3, 0.05],
// share of the powder drag that still acts during the spring return (absorbs ballistic speed)
returnDrag: [0.25, 0, 1, 0.01],
// speed cap on the way home (world units / s): keeps far grains visible instead of crossing the screen in a frame
returnMaxSpeed: [12, 1, 60, 0.5],
landRadius: [0.03, 0.005, 0.2, 0.005],
returnDuration: [2.4, 0.2, 8, 0.05],
returnCurve: [0.35, 0, 1.5, 0.01],
// a landing grain restores its whole break cell (the facet it broke out of) at this rate (1/s; 30 = instant)
cellRestore: [30, 0, 60, 0.5],
// a break cell refills only once all its grains are home; allow this many still in flight
cellStragglers: [0, 0, 20, 1],
// the refilling cell grows back from what is already solid (hole floor, walls, landed shards) at `cellRestore`,
// one voxel layer at a time, instead of the whole facet popping in
growFromEdges: true,
// per-voxel timing variation of every refill, cleanup and refrost timer (0 = a break cell changes look all
// at once, 1 = it dissolves in small patches); breakupScale sets the patch size (higher = smaller)
breakup: [0.7, 0, 1, 0.01],
breakupScale: [10, 1, 40, 0.5],
// returning shards turn to lie flat on the surface they land on (0 = keep facing the camera)
alignToSurface: [1, 0, 1, 0.01],
// distance from home over which a shard turns (world units)
alignDistance: [0.6, 0.05, 3, 0.01],
// FROST: shape of the alignment over the flight home (1 = linear, < 1 early, > 1 late)
alignCurve: [1, 0.2, 4, 0.05],
// a landed shard lies on the surface until its voxel is solid again, then fades over this many seconds
landedFade: [0.25, 0, 2, 0.01],
// shrink a shard over the last part of its flight (0 = it arrives at full size)
landShrink: [0, 0, 0.3, 0.005],
// plus a small sphere of voxels around its rest position (in voxels); 0 = cells only
depositRadius: [0.5, 0, 3, 0.25],
// optional: hidden material comes back as extra dust materialising this far from the surface (0 = off;
// it never rebuilds anything by itself, only the grains that flew out do)
ghostReturnDistance: [0, 0, 1.5, 0.01],
ghostFlightFraction: [0.45, 0.1, 1, 0.01],
// voxels without a grain follow their healed neighbours at this rate, staying `healGap` behind
healRate: [0.6, 0.02, 3, 0.01],
healGap: [0.04, 0, 0.5, 0.01],
// cleanup rate for voxels no grain came back to; starts only after the wave has fully landed
fallbackHeal: [0.15, 0, 0.5, 0.005],
refrostTime: [4.0, 0.2, 12, 0.1],
refrostStrength: [0.3, 0, 1, 0.01],
resetFade: [400, 50, 2000, 10],
} satisfies DialConfig;
export const lightingDefaults = {
key: {
color: "#ffffff",
intensity: [3.2, 0, 12, 0.05],
elevation: [62, 10, 89, 0.5],
azimuth: [18, -90, 90, 0.5],
size: [1.0, 0.2, 3, 0.01],
hoverBoost: [0.06, 0, 0.3, 0.005],
},
fill: [0.18, 0, 1.5, 0.005],
fillColor: "#ffffff",
fillGroundColor: "#262626",
rim: [0.9, 0, 5, 0.01],
rimColor: "#ffffff",
rimElevation: [55, 0, 89, 0.5],
shadow: {
intensity: [1.0, 0, 1, 0.01],
softness: [6, 0, 24, 0.25],
samples: [12, 1, 32, 1],
mapSize: sel("2048", ["1024", "2048", "4096"] as const),
bias: [-0.0006, -0.005, 0.005, 0.0001],
},
sway: { amplitude: [0.03, 0, 0.15, 0.001], period: [12, 2, 40, 0.5] },
backdrop: {
top: "#2a2a2a",
mid: "#050505",
bottom: "#030303",
centerX: [0.5, 0, 1, 0.005],
centerY: [1.02, 0.5, 1.5, 0.005],
radius: [0.55, 0.1, 1.5, 0.005],
falloff: [1.6, 0.5, 4, 0.01],
noise: [1.0, 0, 3, 0.05],
},
envSoftbox: [1.0, 0, 3, 0.01],
envRim: [0.5, 0, 3, 0.01],
envFill: [0.12, 0, 1, 0.005],
} satisfies DialConfig;
export const cameraDefaults = {
fov: [30, 15, 60, 0.5],
distance: [13.5, 4, 24, 0.05],
height: [1.2, -3, 6, 0.01],
lookAtY: [-0.15, -2, 2, 0.01],
parallaxRange: [3, 0, 10, 0.1],
parallaxSmoothing: [0.8, 0.05, 3, 0.01],
rotateYaw: [35, 0, 90, 0.5],
rotatePitch: [10, 0, 45, 0.5],
rotationLag: [1.2, 0.05, 4, 0.01],
baseYaw: [0, -180, 180, 0.5],
basePitch: [0, -90, 90, 0.5],
idleDelay: [4, 0, 15, 0.1],
idleAmplitude: [4, 0, 15, 0.1],
idlePeriod: [24, 4, 80, 0.5],
} satisfies DialConfig;
export const postDefaults = {
dof: {
enabled: true,
focusBias: [0, -3, 3, 0.01],
aperture: [0.9, 0, 4, 0.01],
range: [3.0, 0.2, 12, 0.05],
},
bloom: {
threshold: [1.2, 0, 3, 0.01],
intensity: [0.15, 0, 1.5, 0.005],
radius: [0.15, 0, 1, 0.005],
},
monochrome: [1.0, 0, 1, 0.01],
tonemap: sel("agx", ["agx", "aces", "neutral", "linear"] as const),
exposure: [1.0, 0.1, 4, 0.01],
contrast: [1.08, 0.6, 1.6, 0.005],
blackLift: [0.02, 0, 0.1, 0.001],
vignette: {
strength: [0.2, 0, 1, 0.005],
softness: [0.7, 0.1, 1.5, 0.005],
radius: [0.85, 0.2, 1.6, 0.005],
},
grain: {
strength: [0.03, 0, 0.15, 0.001],
size: [1, 1, 4, 1],
speed: [1, 0, 3, 0.05],
shadowWeight: [0.8, 0, 1, 0.01],
// background-only grain against banding in recorded video: amplitude (0.04 = about 10 grey levels), block
// size in device pixels (use 3+ when the recording is downscaled), 0 speed = static (survives encoding best)
backgroundStrength: [0, 0, 0.25, 0.001],
backgroundSize: [2, 1, 8, 1],
backgroundSpeed: [0, 0, 3, 0.05],
},
dither: true,
aaMode: sel("traa", ["traa", "none"] as const),
pixelRatioCap: [2, 0.5, 2, 0.25],
} satisfies DialConfig;
/** V2: real fragmentation. The object is pre-fractured into rigid chunks that fly out and come back. */
export const fractureDefaults = {
chunks: [600, 40, 3000, 10],
seed: [3, 0, 999, 1],
// a chunk breaks off when the brush passes within brushRadius (+ this share of the chunk's size)
hitPadding: [0.5, 0, 2, 0.05],
eject: {
speed: [2.6, 0, 10, 0.05],
spread: [0.7, 0, 4, 0.05],
spin: [5, 0, 20, 0.1],
jitter: [0.45, 0, 1, 0.01],
backwardRatio: [0.2, 0, 1, 0.01],
},
motion: {
drag: [1.3, 0, 8, 0.01],
angularDrag: [1.6, 0, 8, 0.01],
gravity: [0.3, 0, 3, 0.01],
turbulence: [1.2, 0, 6, 0.05],
turbulenceScale: [1.4, 0.2, 6, 0.05],
maxSpeed: [10, 1, 40, 0.1],
},
return: {
// a chunk turns back this long after it broke off (jittered), or sooner when the cursor is idle
returnAfter: [1.4, 0, 20, 0.05],
returnJitter: [0.9, 0, 5, 0.05],
idleDelay: [0.6, 0, 10, 0.05],
spring: [14, 0.5, 60, 0.1],
damping: [1.0, 0.2, 2, 0.01],
ramp: [0.5, 0, 3, 0.05],
rotationRate: [6, 0.5, 30, 0.1],
snapDistance: [0.015, 0.002, 0.2, 0.001],
},
caps: {
// inner (fracture) faces: fresh break = frosted, crumbly
frost: [0.85, 0, 1, 0.01],
roughness: [0.8, 0, 1, 0.01],
grain: [0.5, 0, 2, 0.01],
darken: [0.15, 0, 1, 0.01],
},
} satisfies DialConfig;
export const performanceDefaults = {
// Dynamic resolution now scales the expensive scene/MRT pass. When nativePostEffects is on the
// final grade, vignette, grain and dither stay at the output DPR and only the 3D work is upscaled.
adaptiveResolution: true,
targetFps: [60, 30, 120, 1],
minPixelRatio: [0.75, 0.5, 2, 0.05],
sceneResolutionScale: [1, 0.5, 1, 0.05],
dynamicSceneResolution: true,
minSceneResolutionScale: [0.35, 0.25, 1, 0.05],
upscaler: sel("taau", ["taau", "fsr1", "bilinear", "native"] as const),
upscaleSharpness: [0.2, 0, 1, 0.05],
nativePostEffects: true,
idleSkip: false, // skip field / particle / haze / density work while nothing is happening (lossless)
adaptiveSteps: false, // crack raymarch: fewer steps where the ice is thin (same step length as the thickest chord)
voronoiCells: sel("27", ["27", "8"] as const), // 8 = jittered-lattice Voronoi, ~3x cheaper cracks, occasional phantom sheet
hazeResolution: sel("full", ["full", "half", "quarter"] as const),
turbulence: sel("full", ["full", "fast"] as const), // fast = swirl from one noise sample instead of a 6-sample curl
gpuTimers: true,
} satisfies DialConfig;
export const debugDefaults = {
_collapsed: true,
showErosionSlice: false,
erosionSliceZ: [0.5, 0, 1, 0.01],
showDensityGrid: false,
showHitPoints: false,
colorByState: false,
colorBySize: false,
colorByAge: false,
wireframe: false,
freeze: false,
stepOnce: { type: "action" as const, label: "Step one frame" },
stats: true,
forceStroke: false,
} satisfies DialConfig;
// ---------------------------------------------------------------------------------------------
// Baked overrides: paste a "Copy all params as JSON" export into ./baked.json and every default
// above is overridden at boot (tuple[0] / select default / plain value). Nothing persists otherwise.
import baked from "./baked.json";
function applyBaked(cfg: any, values: any) {
if (!values || typeof values !== "object") return;
for (const [k, v] of Object.entries(values)) {
if (!Object.hasOwn(cfg, k) || k.startsWith("_")) continue;
const c = cfg[k];
if (Array.isArray(c)) {
if (typeof v === "number") c[0] = v;
} else if (c && typeof c === "object" && "type" in c) {
if ((c as any).type !== "action") (c as any).default = v;
} else if (c && typeof c === "object") applyBaked(c, v);
else cfg[k] = v;
}
}
/** Apply the baked values stored under `key` (e.g. a hero panel) to a DialKit config, in place. */
export function withBaked<T>(key: string, cfg: T): T {
applyBaked(cfg, (baked as any)[key]);
return cfg;
}
export const BAKED_FOLDERS: Record<string, any> = {
shape: shapeDefaults,
ice: iceDefaults,
erosion: erosionDefaults,
powder: powderDefaults,
healing: healingDefaults,
fracture: fractureDefaults,
lighting: lightingDefaults,
camera: cameraDefaults,
post: postDefaults,
performance: performanceDefaults,
debug: debugDefaults,
};
for (const [folder, cfg] of Object.entries(BAKED_FOLDERS)) applyBaked(cfg, (baked as any)[folder]);
if (typeof location !== "undefined" && new URLSearchParams(location.search).has("idleskip"))
(performanceDefaults as any).idleSkip = true;
if (LITE) fractureDefaults.chunks[0] = 120;
if (LITE) {
// headless / software-GPU checks: shrink everything heavy after the baked values are applied
shapeDefaults.segments[0] = 96;
iceDefaults.cracks.steps[0] = 6;
(iceDefaults.cracks as any).fineCracks = false;
iceDefaults.dispersion[0] = 0;
erosionDefaults.resolution.default = "64";
powderDefaults.particleCount.default = "100k";
powderDefaults.densityGrid.default = "32";
powderDefaults.hazeSteps[0] = 8;
}