terrain: death stranding micro pebbles (real geometry, not parallax)

Author: PanosK92

data/shaders/common_resources_gpu_driven.hlsl

@@ -146,10 +146,10 @@ RWStructuredBuffer<uint> restir_pairing : register(u57);
 // declared rw to match the engine pattern for per-pass structured buffers but treated as read-only
 RWStructuredBuffer<EmissiveTriangle> emissive_triangles : register(u49);
 
-// gpu procedural grass, written each frame by grass_populate.hlsl and consumed by the grass raster vs
-// grass_instances is the transient ring buffer, partitioned into one section per lod via lod_base in the push constant
-// grass_count holds one atomic counter per lod, bumped by interlockedadd during the populate dispatch
-// grass_indirect_args holds one DrawIndexedIndirect args entry per lod, the args compute reads grass_count
+// gpu scatter, grass and micro detail, written each frame by grass_populate.hlsl and consumed by the scatter raster vs
+// grass_instances is the transient pool, partitioned into one section per slot per lod via lod_base in the push constant
+// grass_count holds one atomic counter per slot per lod, bumped by interlockedadd during the populate dispatch
+// grass_indirect_args holds one DrawIndexedIndirect args entry per slot per lod, the args compute reads grass_count
 // and bakes index_count / first_index / vertex_offset / first_instance from the per-lod constants
 RWStructuredBuffer<GrassInstance>    grass_instances     : register(u50);
 RWStructuredBuffer<uint>             grass_count         : register(u51);

data/shaders/grass_indirect_args.hlsl

@@ -27,21 +27,24 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 // reads the per-lod atomic counters bumped by grass_populate.hlsl and clamps them into the
 // instance_count field of the per-lod IndirectDrawArgs entries. the other fields (index_count,
-// first_index, vertex_offset, first_instance) were baked once on the cpu in EnableProceduralGrass
+// first_index, vertex_offset, first_instance) were baked once on the cpu in EnableGpuScatter
 // from the grass mesh's per-lod offsets in the global geometry buffer.
 //
-// the args buffer holds renderer_max_grass_lod_count entries laid out contiguously, one per lod,
-// the raster draw calls offset into it by lod_index * sizeof(IndirectDrawArgs) to fetch theirs.
+// the args buffer holds one entry per scatter slot per lod laid out slot major, the raster draw calls
+// offset into it by (slot * lod_count + lod) * sizeof(IndirectDrawArgs) to fetch theirs. this runs once
+// per slot, the cpu pushes the caps of that slot and the index of its first entry.
 //
 // push constant layout (PassBufferData.values):
 //   values[0].xyz = per-lod max_instances cap, one float per lod (must match the populate shader's
 //                   per-lod cap that the cpu pushed into values[0].w of grass_populate.hlsl)
 //   values[0].w   = lod_count
+//   draw_index    = the first args entry of this slot
 
 [numthreads(8, 1, 1)]
 void main_cs(uint3 dispatch_thread_id : SV_DispatchThreadID)
 {
     uint lod_count = (uint)buffer_pass.values[0].w;
+    uint slot_base = buffer_pass.draw_index;
 
     uint lod = dispatch_thread_id.x;
     if (lod >= lod_count)
@@ -51,9 +54,10 @@ void main_cs(uint3 dispatch_thread_id : SV_DispatchThreadID)
     float caps[3]              = { buffer_pass.values[0].x, buffer_pass.values[0].y, buffer_pass.values[0].z };
     uint  max_instances_per_lod = (uint)caps[lod];
 
-    // clamp the atomic counter so the raster never tries to draw more blades than the slot can hold
-    uint instance_count = min(grass_count[lod], max_instances_per_lod);
+    // clamp the atomic counter so the raster never tries to draw more instances than the range can hold
+    uint entry          = slot_base + lod;
+    uint instance_count = min(grass_count[entry], max_instances_per_lod);
 
     // only the instance_count is dynamic, the rest of the args stay frozen at the values the cpu wrote
-    grass_indirect_args[lod].instance_count = instance_count;
+    grass_indirect_args[entry].instance_count = instance_count;
 }

data/shaders/grass_populate.hlsl

@@ -24,13 +24,15 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "common_culling.hlsl"
 //============================
 
-// conservative world-space bound used to cull a blade against the camera frustum and the occluder hi-z
-// covers the tallest scaled blade plus wind sway and the intra-cell scatter, generous enough that no
-// on-screen blade is ever wrongly rejected so visible density stays identical
+// conservative world-space bound used to cull an instance against the camera frustum and the occluder
+// hi-z, covers the tallest scaled instance plus wind sway and the intra-cell scatter, generous enough
+// that nothing on screen is ever wrongly rejected so visible density stays identical. both are scaled
+// by the slot's largest instance, a stone chip a few centimetres across does not need a metre of slack
 static const float grass_cull_half_height = 0.5f;
 static const float grass_cull_radius      = 1.5f;
 
-// gpu procedural grass placement (ghost of tsushima style)
+// gpu scatter placement (ghost of tsushima style), slot 0 is grass and the higher slots are micro
+// detail, pebbles and chips, the same ring machinery with a different mesh and a tighter reach
 //
 // one thread per cell in a 2d ring around the camera, the ring lives entirely inside grass_instances
 // each accepted cell is atomically committed into the per-lod section of the buffer and the per-lod
@@ -44,6 +46,12 @@ static const float grass_cull_radius      = 1.5f;
 //   values[0] = (cell_size, ring_radius, lod_base_in_instances, max_instances_per_lod)
 //   values[1] = (height_min, height_max, max_slope_cos, inner_radius)
 //   values[2] = (map_origin_x, map_origin_z, map_inv_size_x, map_inv_size_z)
+// every float is taken, so the rest travels in the bits of draw_index:
+//   bits 0-3   lod ring
+//   bits 4-7   scatter slot
+//   bits 8-11  prop mask channel, 0 grass, 1 trees, 2 rocks
+//   bits 12-19 packed instance scale at the small end of the size range
+//   bits 20-27 packed instance scale at the large end
 // camera xz comes from buffer_frame
 // terrain height is r32 local y bound to tex (t7), material_index bitcast is the entity y
 // biome_min arrives asfloat(is_transparent), negative disables the gate
@@ -189,7 +197,22 @@ void main_cs(uint3 dispatch_thread_id : SV_DispatchThreadID)
     float height_max    = buffer_pass.values[1].y;
     float max_slope_cos = buffer_pass.values[1].z;
     float inner_radius  = buffer_pass.values[1].w;
-    uint  lod_index     = buffer_pass.draw_index;
+
+    uint  packed_index  = buffer_pass.draw_index;
+    uint  lod_index     = packed_index & 0xFu;
+    uint  slot_index    = (packed_index >> 4)  & 0xFu;
+    uint  mask_channel  = (packed_index >> 8)  & 0xFu;
+    float scale_01_min  = float((packed_index >> 12) & 0xFFu) / 255.0f;
+    float scale_01_max  = float((packed_index >> 20) & 0xFFu) / 255.0f;
+
+    // the counters and the indirect args are laid out slot major, matches renderer_gpu_scatter_arg_index
+    uint  count_index   = slot_index * 3u + lod_index;
+
+    // the cull sphere has to grow with the instance, compose_instance_transform maps the packed scale
+    // logarithmically over 0.01 to 100 and the raster will unpack it exactly the same way
+    float largest_scale = exp2(lerp(-6.643856f, 6.643856f, scale_01_max));
+    float cull_radius   = grass_cull_radius * largest_scale;
+    float cull_height   = grass_cull_half_height * largest_scale;
 
     float2 camera_xz_anchor = get_camera_position().xz;
 
@@ -226,8 +249,14 @@ void main_cs(uint3 dispatch_thread_id : SV_DispatchThreadID)
     // hash combines the cell coordinates, the blade index inside the cell, and the lod seed,
     // each (cell, blade) pair gets an independent stable hash, no two blades collide and there is
     // no per-cell pattern because blade_index decorrelates blades that share a cell
+    // the slot is part of the seed, otherwise every slot would stack its instances on the exact same
+    // points and a pebble would be born inside every blade of grass
     uint blade_index = dispatch_thread_id.z;
-    uint h0  = hash_u32((uint)world_cell_x, (uint)world_cell_z, lod_index * 2654435761u + blade_index * 0x9e3779b9u);
+    uint h0  = hash_u32(
+        (uint)world_cell_x,
+        (uint)world_cell_z,
+        lod_index * 2654435761u + blade_index * 0x9e3779b9u + slot_index * 0x85ebca6bu
+    );
     float jx = hash_unit(h0);
     float jz = hash_unit(h0 * 16807u + 1u);
     float ys = hash_unit(h0 * 48271u + 3u);
@@ -312,17 +341,17 @@ void main_cs(uint3 dispatch_thread_id : SV_DispatchThreadID)
     // visibility cull, frustum + occluder hi-z on a conservative blade sphere, only blades the camera
     // can actually see survive so on-screen density is unchanged while off-screen and occluded blades
     // are dropped before the expensive slope taps, vertex shading and the atomic allocate
-    float3 blade_center = float3(world_xz.x, world_y + grass_cull_half_height, world_xz.y);
+    float3 blade_center = float3(world_xz.x, world_y + cull_height, world_xz.y);
     float4 plane_l, plane_r, plane_b, plane_t;
     get_frustum_side_planes(plane_l, plane_r, plane_b, plane_t);
-    if (!sphere_in_side_planes(blade_center, grass_cull_radius, plane_l, plane_r, plane_b, plane_t))
+    if (!sphere_in_side_planes(blade_center, cull_radius, plane_l, plane_r, plane_b, plane_t))
         return;
 
     // hi-z arrives on tex2, derive the max mip from the texture so no extra push constant is needed
     // the sphere test also rejects blades behind the camera (the side planes alone do not)
     uint hiz_w, hiz_h, hiz_mips;
     tex2.GetDimensions(0, hiz_w, hiz_h, hiz_mips);
-    if (!sphere_hiz_visible(tex2, blade_center, grass_cull_radius, float(hiz_mips - 1u)))
+    if (!sphere_hiz_visible(tex2, blade_center, cull_radius, float(hiz_mips - 1u)))
         return;
 
     // slope reject, two forward taps reusing the centre height, paid only by visible blades
@@ -336,7 +365,7 @@ void main_cs(uint3 dispatch_thread_id : SV_DispatchThreadID)
         return;
     }
 
-    // biome grass mask, same uv as the heightfield, r channel is grass suitability
+    // biome mask, same uv as the heightfield, the slot picks the channel it is gated on
     // is_transparent carries biome_min as float bits, negative disables the gate
     float biome_min = asfloat(buffer_pass.is_transparent);
     if (biome_min >= 0.0f)
@@ -350,7 +379,8 @@ void main_cs(uint3 dispatch_thread_id : SV_DispatchThreadID)
             terrain_world_to_normalized(world_xz),
             float2(mask_w, mask_h)
         );
-        float grass_w = tex3.SampleLevel(samplers[sampler_bilinear_clamp], mask_uv, 0).r;
+        float4 mask     = tex3.SampleLevel(samplers[sampler_bilinear_clamp], mask_uv, 0);
+        float grass_w   = mask_channel == 0u ? mask.r : (mask_channel == 1u ? mask.g : mask.b);
         float slope_fit = saturate((surface_normal.y - max_slope_cos) / max(1.0f - max_slope_cos, 1e-4f));
         grass_w *= slope_fit;
         if (grass_w < biome_min)
@@ -365,14 +395,15 @@ void main_cs(uint3 dispatch_thread_id : SV_DispatchThreadID)
         }
     }
 
-    // keep the authored blade proportions within a natural range
-    float scale_01 = 0.5f + (sc - 0.5f) * 0.05f;
+    // one roll inside the authored size range, the ends arrive already packed the way the raster
+    // unpacks them so no size ever leaves the range the layer asked for
+    float scale_01 = lerp(scale_01_min, scale_01_max, sc);
 
     // atomic-allocate a slot inside this lod's section, bail out cleanly once full
     // blades_per_cell was sized from cells_in_ring with floor() so the upper bound on writes is
     // floor(cap / cells_in_ring) * cells_in_ring <= cap, the clamp here is just a defensive guard
     uint local_slot;
-    InterlockedAdd(grass_count[lod_index], 1u, local_slot);
+    InterlockedAdd(grass_count[count_index], 1u, local_slot);
     if (local_slot >= max_instances_per_lod)
         return;
 

data/shaders/taau.hlsl

@@ -31,7 +31,7 @@ static const float box_widen_static   = 0.5f;
 static const float box_pad_relative   = 0.08f;
 static const float box_pad_absolute   = 0.002f;
 static const float box_pad_hdr        = 0.2f;
-// relative depth, same surface, jitter and precision only
+// relative depth tolerance for same surface
 static const float reuse_depth_tol = 0.02f;
 
 float3 tonemap_for_taa(float3 c)
@@ -109,8 +109,7 @@ float3 clip_to_aabb(float3 box_min, float3 box_max, float3 history)
     return (ratio > 1.0f) ? (center + offset * rcp(ratio)) : history;
 }
 
-// sky has no gbuffer velocity, rebuild camera rotation at infinity so history
-// tracks the dome instead of smearing into curved ghost trails
+// sky has no gbuffer velocity, rebuild camera rotation at infinity
 float2 compute_sky_velocity(float2 uv)
 {
     matrix vp_curr = pass_is_right_eye() ?
@@ -133,9 +132,7 @@ float2 compute_sky_velocity(float2 uv)
     return curr_clip.xy / max(curr_clip.w, 1e-6f) - prev_clip.xy / max(prev_clip.w, 1e-6f);
 }
 
-// expected previous depth of this surface versus what was actually stored,
-// sampled at the reprojected jittered uv so a still camera is not compared
-// against the wrong texel
+// compare expected previous depth of this surface against what was stored
 float compute_history_reuse(int2 px_render, float2 res_render, int2 px_render_max, float2 velocity_ndc)
 {
     float  depth_raw = tex_depth[px_render].r;
@@ -163,8 +160,7 @@ float compute_history_reuse(int2 px_render, float2 res_render, int2 px_render_ma
         return 1.0f;
     }
 
-    // mismatch, keep only if a still neighbour owns that previous depth, jitter
-    // across a static silhouette, a moving neighbour is an occluder that left
+    // mismatch, keep only if a still neighbour owns that previous depth
     static const float still_px = 0.5f;
     static const int2 n4[4] =
     {
@@ -230,7 +226,7 @@ float3 taau(uint2 px_out, float2 res_out)
     int2  closest_px    = center;
     float closest_depth = -1.0f;
 
-    // 3x3 neighborhood for reconstruct + near aabb, corners only for the wide clamp
+    // corners widen the near aabb built from the 3x3
     static const int2 wide_corners[4] =
     {
         int2(-2, -2), int2( 2, -2),
@@ -297,7 +293,7 @@ float3 taau(uint2 px_out, float2 res_out)
     bool current_valid = weight_sum > 0.0f;
     current_rgb_tm     = current_valid ? current_rgb_tm * rcp(weight_sum) : 0.0f.xxx;
 
-    // dilated velocity is for history uv only, the reuse test must use this pixel
+    // dilated velocity is for the history uv only, the reuse test uses this pixel
     float  center_depth    = tex_depth[center].r;
     bool   is_sky          = center_depth < 1e-4f;
     float2 velocity_center = tex_velocity[center].xy;
@@ -315,7 +311,6 @@ float3 taau(uint2 px_out, float2 res_out)
 
     if (!current_valid)
     {
-        // no current signal, try history at this uv
         float3 fallback = tex.SampleLevel(samplers[sampler_bilinear_clamp], uv_out, 0.0f).rgb;
         return saturate_16(max(fallback, 0.0f.xxx));
     }
@@ -328,7 +323,7 @@ float3 taau(uint2 px_out, float2 res_out)
     float motion_px = length(velocity_uv * res_out);
     float motion    = saturate(motion_px * rcp(motion_px_full));
 
-    // always test, a revealed sky pixel has no velocity so a motion gate would keep the ghost
+    // never gate on motion, a revealed sky pixel has no velocity
     float reuse = compute_history_reuse(center, active_render_f, px_render_max, velocity_center);
     if (reuse < 1.0f)
     {
@@ -345,8 +340,7 @@ float3 taau(uint2 px_out, float2 res_out)
     float3 rgb_min = lerp(rgb_min_near, rgb_min_wide, widen);
     float3 rgb_max = lerp(rgb_max_near, rgb_max_wide, widen);
 
-    // the reinhard curve compresses highlights, so a fixed tolerance in tonemapped space is a
-    // tiny tolerance in linear space, this restores a constant relative tolerance for bright taps
+    // reinhard compresses highlights, restore a constant relative tolerance for bright taps
     float  box_level = max3(rgb_max);
     float  pad_hdr   = box_pad_hdr * box_level * (1.0f - box_level);
     float3 box_pad   = max((rgb_max - rgb_min) * box_pad_relative, max(box_pad_absolute, pad_hdr));
@@ -358,8 +352,7 @@ float3 taau(uint2 px_out, float2 res_out)
 
     float blend_base = lerp(blend_static, blend_motion, motion);
 
-    // measured back in linear, a small wobble at the top of the reinhard curve is a large
-    // brightness swing and that is what makes saturated highlights read as unstable
+    // measure in linear, a small wobble at the top of the curve is a large brightness swing
     float curr_l    = max3(tonemap_for_taa_inv(current_rgb_tm));
     float hist_l    = max3(tonemap_for_taa_inv(history_clipped_tm));
     float disagree  = abs(curr_l - hist_l) * rcp(max(max(curr_l, hist_l), 0.1f));