Give the snow a fluffy clumpy texture and a snow ground, Disney-style

Follows the reference look (Stomakhin snow slab/snowball) the user pointed
at. Three changes:

- Baked clumpy micro-relief: after decimation+Taubin, the surface is pushed
  along its normal by a fixed 3D value-noise field (CLUMP=0.42 cell,
  CLUMP_FREQ=3/cell ~ 1.5cm clods). Fixed in space, so settled snow doesn't
  shimmer; applied after smoothing so the high-frequency part survives.
- The ground is now packed snow (bright bluish-white, strong bump grain),
  not a bare pale floor -- matching the reference where the slab itself is
  snow, and giving the thin debris carpet a snow bed to sit on.
- Hemisphere light now reads as an overcast sky (white above, cool snow-blue
  bounce below) so shadowed snow picks up the bluish tint; sun is slightly
  warm.

Known limit, stated honestly: the settled carpet is still physically 1-2
particles (~5mm) thick, so a straight top-down view still reads as texture
plus terrain rather than volume -- no renderer can give a 5mm sheet side
area from above. Making the floor a real simulated snow bed the letters
crater into would fix that, at the cost of a re-sim and ~2x payload.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: zlyfunction

mpm_demo/data/google_drop/surface.bin.gz

@@ -113,6 +113,41 @@
 
 
 SMOOTH_ITERS = 3      # Taubin smoothing passes on the decimated mesh
+CLUMP = 0.42          # baked clumpy micro-relief: fraction of a cell that the
+                      # decimated surface is pushed in/out along its normal by
+                      # a fixed 3D value-noise field. The Disney renders get
+                      # their "fluffy clods" from real grain-scale geometry;
+                      # at our 5mm cells that scale is far below the mesh, so
+                      # the nearest achievable thing is to dither the surface
+                      # with a fixed ~1-2cm noise. Fixed in space, not per
+                      # frame, so settled snow shimmers no more than before.
+CLUMP_FREQ = 3.0      # noise frequency, cycles per cell (above the 5mm mesh
+                      # scale, so it reads as grain rather than as lumps)
+_NOISE = None         # lazily built fixed permutation + value table
+
+
+def _noise3(p):
+    """Deterministic trilinear value noise, p in cell units, out in [-1,1].
+    Fixed table -> the same world point always gets the same value, so the
+    relief is stable frame to frame even as the mesh is rebuilt."""
+    global _NOISE
+    if _NOISE is None:
+        rng = np.random.default_rng(11)
+        _NOISE = rng.random((64, 64, 64))
+    i = np.floor(p).astype(np.int64)
+    f = p - i
+    f = f * f * (3 - 2 * f)  # smoothstep
+    i0 = i % 64
+    i1 = (i + 1) % 64
+    n = _NOISE
+    c000 = n[i0[:, 0], i0[:, 1], i0[:, 2]]; c100 = n[i1[:, 0], i0[:, 1], i0[:, 2]]
+    c010 = n[i0[:, 0], i1[:, 1], i0[:, 2]]; c110 = n[i1[:, 0], i1[:, 1], i0[:, 2]]
+    c001 = n[i0[:, 0], i0[:, 1], i1[:, 2]]; c101 = n[i1[:, 0], i0[:, 1], i1[:, 2]]
+    c011 = n[i0[:, 0], i1[:, 1], i1[:, 2]]; c111 = n[i1[:, 0], i1[:, 1], i1[:, 2]]
+    x00 = c000 + f[:, 0] * (c100 - c000); x10 = c010 + f[:, 0] * (c110 - c010)
+    x01 = c001 + f[:, 0] * (c101 - c001); x11 = c011 + f[:, 0] * (c111 - c011)
+    y0 = x00 + f[:, 1] * (x10 - x00); y1 = x01 + f[:, 1] * (x11 - x01)
+    return (y0 + f[:, 2] * (y1 - y0)) * 2 - 1
 
 
 def taubin_smooth(verts, faces, iters=SMOOTH_ITERS, lam=0.5, mu=-0.53):
@@ -196,6 +231,22 @@ def reconstruct(points, tree_colors_f32, cell, y_floor, iso):
     if SMOOTH_ITERS and len(faces):
         verts = taubin_smooth(verts, faces.astype(np.int64))
 
+    # bake the fluffy clods: push the decimated surface along its own normal
+    # by the fixed noise field. Done *after* smoothing so the high-frequency
+    # component survives (Taubin would otherwise iron exactly this out).
+    if CLUMP and len(faces):
+        v = verts.astype(np.float64)
+        n = np.zeros_like(v)
+        tris = v[faces.astype(np.int64)]
+        fn = np.cross(tris[:, 1] - tris[:, 0], tris[:, 2] - tris[:, 0])
+        for c in range(3):
+            np.add.at(n, faces[:, c].astype(np.int64), fn)
+        ln = np.linalg.norm(n, axis=1)
+        ln[ln == 0] = 1.0
+        n /= ln[:, None]
+        disp = CLUMP * cell * _noise3(verts * (CLUMP_FREQ / cell))
+        verts = (v + n * disp[:, None]).astype(np.float32)
+
     tree = cKDTree(points)
     dist, nn = tree.query(verts, k=COLOR_K, workers=-1)
     # inverse-cube distance weighting: smooths noise among same-letter

mpm_demo/gen/bake_surface.py

@@ -219,9 +219,11 @@ <h2>WHAT IS THIS?</h2>
 controls.minDistance = 0.3;
 controls.maxDistance = 12;
 
-const hemi = new THREE.HemisphereLight(0xffffff, 0x445566, 0.6);
+// hemisphere light like an overcast sky: white from above, cool snow-blue
+// bounce from below -- this is where snow's bluish shadow tint comes from
+const hemi = new THREE.HemisphereLight(0xffffff, 0x8fa8cc, 0.6);
 scene.add(hemi);
-const sun = new THREE.DirectionalLight(0xffffff, 2.4);
+const sun = new THREE.DirectionalLight(0xfff2e0, 2.4);
 sun.castShadow = true;
 sun.shadow.mapSize.set(2048, 2048);
 sun.shadow.bias = -0.0006;
@@ -246,6 +248,7 @@ <h2>WHAT IS THIS?</h2>
 ssaoPass.kernelRadius = 0.008;
 ssaoPass.minDistance = 0.00003;
 ssaoPass.maxDistance = 0.003;
+ssaoPass.output = SSAOPass.OUTPUT.Default;
 composer.addPass(ssaoPass);
 composer.addPass(new OutputPass());
 
@@ -423,11 +426,13 @@ <h2>WHAT IS THIS?</h2>
     groundGeo.setAttribute('position', new THREE.BufferAttribute(gpos, 3));
     groundGeo.setIndex(g.indices);
     groundGeo.computeVertexNormals();
+    // the ground *is* packed snow, like the slab in the Disney reference
+    // footage -- bright, granular-textured, slightly bluish in shadow
     const groundMat = new THREE.MeshPhysicalMaterial({
-        color: 0xc7d2e0, roughness: 0.9, metalness: 0.0, side: THREE.DoubleSide,
-        sheen: 1.0, sheenRoughness: 0.75, sheenColor: 0xffffff,
-        bumpMap: noiseTex, bumpScale: 0.0015,
-        envMapIntensity: 0.3,
+        color: 0xe8edf4, roughness: 0.95, metalness: 0.0, side: THREE.DoubleSide,
+        sheen: 1.0, sheenRoughness: 0.85, sheenColor: 0xffffff,
+        bumpMap: noiseTex, bumpScale: 0.006,
+        envMapIntensity: 0.35,
     });
     const groundMesh = new THREE.Mesh(groundGeo, groundMat);
     groundMesh.receiveShadow = true;
@@ -531,12 +536,12 @@ <h2>WHAT IS THIS?</h2>
         surfGeo.setIndex(new THREE.BufferAttribute(new Uint16Array(surfMeta.maxTris * 3), 1));
         const surfMat = new THREE.MeshPhysicalMaterial({
             vertexColors: true,   // geometry really has a `color` attribute here
-            color: 0xffffff, roughness: 0.8, metalness: 0.0,
+            color: 0xffffff, roughness: 0.85, metalness: 0.0,
             // sheen kept moderate: a full white sheen layer washes the
             // letter colors out to pastel
             sheen: 0.55, sheenRoughness: 0.5, sheenColor: 0xffffff,
             clearcoat: 0.1, clearcoatRoughness: 0.6,
-            bumpMap: noiseTex, bumpScale: 0.0014,
+            bumpMap: noiseTex, bumpScale: 0.0022,
             envMapIntensity: 0.3,
         });
         const surfMesh = new THREE.Mesh(surfGeo, surfMat);