Implement Fog Of War

Implement Fog of War

Build fog of war as a shared perception system with a restrained presentation layer.

Preserve the architecture

Keep these responsibilities separate:

1. Let deterministic CPU perception own ranges, obstacle intersections, and gameplay visibility.
2. Encode the player's angular visible distances into one fixed-size lookup texture.
3. Let one full-screen shader turn that lookup into soft radial and wall-aware fog.
4. Let gameplay consume perception results directly; never infer combat truth from fog pixels.

Read mechanics.md before implementing or changing the algorithm. It records the proven obstacle model, shader composition, calibrated values, state rules, enemy behavior, lighting constraints, and telemetry.

Inspect before editing

• Locate the authoritative player position, camera, obstacles, scene lifecycle, frame loop, targeting, enemy perception, and render layers.
• Confirm the gameplay ground model. The proven corner-unprojection method assumes a locally horizontal plane; use authoritative surface or terrain reconstruction when elevation varies across the visible area.
• Find existing scene fog, post-processing, renderer creation, review modes, menus, captures, transitions, and disposal paths.
• Read the current tests and recent fog/perception commits before changing constants or ownership.
• Confirm whether obstacle state changes at runtime. Reuse the same active obstacle collection used by navigation or collision when its geometry is suitable for sight.
• Check the working tree early and preserve unrelated changes.

Implement in dependency order

1. Define perception truth

• Represent each sight blocker with a stable footprint, vertical span, and active state.
• Intersect a 3D sight segment or ray with both the horizontal footprint and vertical span.
• Ignore inactive blockers and cover below the eye-to-target sight line.
• Expose:
  • point-to-point perception for enemies, targeting, and attacks;
  • a deterministic angular distance fill for the fog lookup.
• Use explicit player and enemy ranges. Allow them to differ when the encounter design needs enemies to acquire beyond the player's reveal edge.

2. Build the visibility lookup

• Allocate the distance array, byte pixels, and data texture once.
• Cast a fixed number of evenly spaced horizontal rays around the player's eye point.
• Normalize hit distances by the player vision radius and quantize them into a one-row red-channel texture.
• Use linear filtering, horizontal repeat wrapping, no mipmaps, and a bounded mobile/desktop ray budget.
• Refresh after meaningful player motion or a short maximum interval. Do not allocate in the frame loop.

3. Render one soft overlay

• Use one clip-space plane and one transparent shader material.
• Reconstruct each fragment's ground-plane position from the four camera-corner intersections.
• Combine:
  • a clear inner radius and soft outer radial falloff;
  • a feathered wall boundary sampled from the angular lookup.
• Smooth obstacle visibility across neighboring angles. Weight wall fog below the outer radial fog so blockers read as atmosphere, not opaque wedges.
• Combine radial and obstacle fog with max, then cap final opacity.
• Disable depth test, depth write, and tone mapping; render after the world.
• Do not introduce a second renderer, render target, composer, or per-ray meshes.