fix(client): move fog blur to CPU pipeline, fix GL compat bilinear on RGBA8
Replaces GPU 7×7/5×5 Gaussian blur (98 texture reads/px) with CPU-side Gaussian blur (sigma 2.0) + 4× bilinear upscale + RGBA8 convert in fog_state.gd. GL compatibility mode doesn't bilinear-filter R8 textures; RGBA8 at 4× resolution resolves this. Squared exp_fade at the explored/unexplored boundary keeps fog opaque near tile content edges, fixing the staircase artifact. Shader now does 2 texture reads per pixel. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 4.6
@@ -32,6 +32,7 @@ func _ready() -> void:
|
||||
|
||||
# Create seamless noise texture for fog animation
|
||||
var noise := FastNoiseLite.new()
|
||||
noise.seed = 42
|
||||
noise.noise_type = FastNoiseLite.TYPE_PERLIN
|
||||
noise.frequency = 0.03
|
||||
var noise_tex := NoiseTexture2D.new()
|
||||
|
||||
+21
-59
@@ -1,17 +1,21 @@
|
||||
shader_type canvas_item;
|
||||
|
||||
// D-059/D-015: 3-state fog shader (simplified from 5-layer by #569).
|
||||
// State 1: Clear (forward cone) — transparent, soft Gaussian gradient edge (3-4 tile radius)
|
||||
// State 1: Clear (forward cone) — transparent, soft gradient edge (6-8 tile radius)
|
||||
// State 2: Explored (out of cone) — light fog overlay, alpha 0.25-0.35, zone temperature tint,
|
||||
// 8-10s Perlin breathe. Art and information preserved, just "not fresh" (D-015).
|
||||
// State 3: Unexplored — solid near-black #12141a
|
||||
// D-033: Entity colors are NOT affected — they render above the fog overlay (z-layer 5).
|
||||
// D-046: Zone temperature tint from zone_tint_tex — warm=bar, cool=hub, neutral=corridor.
|
||||
// D-077: zone_tint_tex populated per-tile from server zone_id via fog_state.gd.
|
||||
//
|
||||
// Texture pipeline (fog_state.gd): binary 0/255 at 1× tile resolution → CPU Gaussian blur
|
||||
// (sigma 2.0, 6-8 tile gradient) → Image.resize 4× bilinear upscale → RGBA8 convert.
|
||||
// Textures arrive here with smooth sub-tile gradients — no GPU-side blur needed.
|
||||
|
||||
uniform sampler2D visibility_tex : filter_linear, repeat_disable;
|
||||
uniform sampler2D exploration_tex : filter_linear, repeat_disable;
|
||||
uniform sampler2D zone_tint_tex : filter_nearest, repeat_disable; // nearest: zones have hard boundaries (D-073)
|
||||
uniform sampler2D visibility_tex : filter_linear, repeat_disable; // RGBA8, 4× tile resolution
|
||||
uniform sampler2D exploration_tex : filter_linear, repeat_disable; // RGBA8, 4× tile resolution
|
||||
uniform sampler2D zone_tint_tex : filter_nearest, repeat_disable; // D-073: hard zone boundaries
|
||||
uniform sampler2D noise_tex : filter_linear, repeat_enable;
|
||||
uniform vec2 rect_pos; // World-space position of the ColorRect (pixels)
|
||||
uniform vec2 rect_sz; // World-space size of the ColorRect (pixels)
|
||||
@@ -23,40 +27,6 @@ uniform bool debug_exploration = false; // When true, render raw exploration tex
|
||||
|
||||
const vec3 UNEXPLORED_COLOR = vec3(0.071, 0.078, 0.102); // #12141a
|
||||
|
||||
// Soft gradient via 7x7 Gaussian blur on visibility (sigma 2.0).
|
||||
// Spreads the cone boundary into a 3-4 tile radius gradient — no hard tile-stepped edges.
|
||||
float sample_visibility(vec2 uv) {
|
||||
vec2 t = 2.0 / map_size;
|
||||
float sum = 0.0;
|
||||
float weight = 0.0;
|
||||
for (float dy = -3.0; dy <= 3.0; dy += 1.0) {
|
||||
for (float dx = -3.0; dx <= 3.0; dx += 1.0) {
|
||||
float w = exp(-(dx * dx + dy * dy) / 8.0);
|
||||
vec2 sample_uv = clamp(uv + vec2(dx, dy) * t, vec2(0.0), vec2(1.0));
|
||||
sum += texture(visibility_tex, sample_uv).r * w;
|
||||
weight += w;
|
||||
}
|
||||
}
|
||||
return sum / weight;
|
||||
}
|
||||
|
||||
// Soft gradient on exploration boundary (5x5, sigma 1.5).
|
||||
// Prevents hard tile-stepped staircase at explored/unexplored edge.
|
||||
float sample_exploration(vec2 uv) {
|
||||
vec2 t = 1.0 / map_size;
|
||||
float sum = 0.0;
|
||||
float weight = 0.0;
|
||||
for (float dy = -2.0; dy <= 2.0; dy += 1.0) {
|
||||
for (float dx = -2.0; dx <= 2.0; dx += 1.0) {
|
||||
float w = exp(-(dx * dx + dy * dy) / 4.5);
|
||||
vec2 sample_uv = clamp(uv + vec2(dx, dy) * t, vec2(0.0), vec2(1.0));
|
||||
sum += texture(exploration_tex, sample_uv).r * w;
|
||||
weight += w;
|
||||
}
|
||||
}
|
||||
return sum / weight;
|
||||
}
|
||||
|
||||
void fragment() {
|
||||
vec2 world_px = rect_pos + UV * rect_sz;
|
||||
vec2 tile = world_px / tile_size;
|
||||
@@ -67,28 +37,15 @@ void fragment() {
|
||||
if (tex_uv.x < 0.0 || tex_uv.x > 1.0 || tex_uv.y < 0.0 || tex_uv.y > 1.0) {
|
||||
COLOR = vec4(UNEXPLORED_COLOR, 1.0);
|
||||
|
||||
// Debug mode: render raw exploration texture (bypass fog rendering).
|
||||
// Green = EXP_VISIBLE (255), blue = EXP_EXPLORED (128), red = EXP_UNEXPLORED (0).
|
||||
// Debug mode: render RAW exploration texture with filter_linear.
|
||||
// If hardware bilinear works, should show smooth sub-tile gradients.
|
||||
} else if (debug_exploration) {
|
||||
float explored_dbg = texture(exploration_tex, tex_uv).r;
|
||||
if (explored_dbg > 0.9) {
|
||||
COLOR = vec4(0.0, explored_dbg, 0.0, 0.8); // Green: currently visible
|
||||
} else if (explored_dbg > 0.1) {
|
||||
COLOR = vec4(0.0, 0.0, explored_dbg * 2.0, 0.8); // Blue: explored
|
||||
} else {
|
||||
COLOR = vec4(0.5, 0.0, 0.0, 0.8); // Red: unexplored
|
||||
}
|
||||
float explored_raw = texture(exploration_tex, tex_uv).r;
|
||||
COLOR = vec4(vec3(explored_raw), 0.9);
|
||||
|
||||
} else {
|
||||
float vis_raw = texture(visibility_tex, tex_uv).r;
|
||||
float vis = sample_visibility(tex_uv);
|
||||
float explored_raw = texture(exploration_tex, tex_uv).r;
|
||||
float explored = sample_exploration(tex_uv);
|
||||
|
||||
// Prevent gradient bleed into never-explored tiles (use raw, unblurred value)
|
||||
if (explored_raw < 0.01 && vis_raw < 0.01) {
|
||||
vis = 0.0;
|
||||
}
|
||||
float vis = texture(visibility_tex, tex_uv).r;
|
||||
float explored = texture(exploration_tex, tex_uv).r;
|
||||
|
||||
if (explored < 0.01 && vis < 0.01) {
|
||||
// Unexplored: solid near-black — information zero
|
||||
@@ -106,8 +63,13 @@ void fragment() {
|
||||
float alpha = mix(fog_alpha, 0.0, clarity);
|
||||
vec3 color = mix(zone_tint, vec3(0.0), clarity);
|
||||
|
||||
// Soft edge between explored and unexplored (blurred to avoid staircase)
|
||||
float exp_fade = smoothstep(0.0, 0.3, explored);
|
||||
// Soft edge between explored and unexplored.
|
||||
// The exploration texture is binary (explored-or-not) blurred over ~12 tiles.
|
||||
// At the physical tile boundary, explored ≈ 0.5. Squaring the fade keeps
|
||||
// fog nearly opaque there (97%), hiding tile-aligned content edges.
|
||||
// Content appears gradually 4-6 tiles inside the explored area.
|
||||
float exp_fade = smoothstep(0.3, 1.0, explored);
|
||||
exp_fade *= exp_fade; // Steeper curve: fog stays opaque near content edge
|
||||
alpha = mix(1.0, alpha, exp_fade);
|
||||
color = mix(UNEXPLORED_COLOR, color, exp_fade);
|
||||
|
||||
|
||||
@@ -10,16 +10,23 @@ The fog system was simplified from the original 5-layer spec in Sprint 22 (#569)
|
||||
|
||||
| Original D-059 Layer | Sprint 22 Status | Notes |
|
||||
|----------------------|------------------|-------|
|
||||
| 1. Clear (forward cone) | Implemented | Soft Gaussian gradient (7x7, sigma 2.0) |
|
||||
| 2. Light fog (cone gradient) | Simplified — merged into gradient | Peripheral sector removed from server (#569); Gaussian blur provides soft transition |
|
||||
| 3. Deep fog (previously explored) | Implemented — EXP_EXPLORED | Alpha 0.55-0.70 with zone temperature tint (#563) |
|
||||
| 1. Clear (forward cone) | Implemented | CPU Gaussian blur (sigma 2.0) → 4× bilinear upscale → RGBA8. Smooth sub-tile gradients. |
|
||||
| 2. Light fog (cone gradient) | Simplified — merged into gradient | Peripheral sector removed from server (#569); CPU blur + bilinear upscale provides soft transition |
|
||||
| 3. Deep fog (previously explored) | Simplified — D-015 light fog | Alpha 0.25-0.35 with zone temperature tint. Explored tiles show through light haze. |
|
||||
| 4. Unexplored + maps app | Deferred | v0.1.2+, requires mapped_tiles in ObserverSnapshot |
|
||||
| 5. Unexplored (no maps) | Implemented | Solid near-black #12141a |
|
||||
|
||||
**Alpha values (Sprint 22, #563):**
|
||||
- Light fog zone (near cone gradient, vis 0.0-0.3): alpha 0.25-0.35, breathing ±0.05 (8-10s)
|
||||
- Deep fog zone (EXP_EXPLORED, vis≈0): alpha 0.55-0.70, breathing ±0.075 (15-20s)
|
||||
- Zone temperature tint active in deep fog zone (D-059/D-046/D-077)
|
||||
**Texture pipeline (fog_state.gd):**
|
||||
Binary 0/255 data at 1× tile resolution → CPU Gaussian blur (sigma 2.0, radius 4)
|
||||
→ `Image.resize()` 4× bilinear upscale → `Image.convert()` RGBA8.
|
||||
GL compat mode doesn't bilinear-filter R8 textures; RGBA8 at 4× resolves this.
|
||||
Exploration data is binarized (0/128/255 → 0/255) before blur to avoid a
|
||||
second gradient at the explored/visible boundary.
|
||||
|
||||
**Alpha values (Sprint 22, D-015):**
|
||||
- Light fog zone (explored, out of cone): alpha 0.25-0.35, breathing ±0.05 (8-10s)
|
||||
- Zone temperature tint active in explored zone (D-059/D-046/D-077)
|
||||
- Explored/unexplored boundary: squared fade keeps fog opaque at tile content edge
|
||||
|
||||
## Overview
|
||||
|
||||
@@ -120,30 +127,27 @@ func update_from_state() -> void:
|
||||
|
||||
File: `client/shaders/fog.gdshader`
|
||||
|
||||
The shader determines fog state per pixel based on the visibility and exploration textures.
|
||||
Two explored sub-zones are distinguished by the blurred `vis` value (proximity to the forward cone):
|
||||
The shader reads pre-smoothed RGBA8 textures (CPU blur + 4× bilinear upscale)
|
||||
and determines fog state per pixel. No GPU-side blur — 2 texture reads per pixel.
|
||||
|
||||
```glsl
|
||||
// Light fog noise — fast cycle (8-10s), subtle ±0.05 breathing
|
||||
float noise_fast = texture(noise_tex, tile * 0.03 + vec2(time * 0.11, time * 0.07)).r;
|
||||
// Deep fog noise — slow cycle (15-20s), more pronounced ±0.075 breathing
|
||||
float noise_slow = texture(noise_tex, tile * 0.02 + vec2(time * 0.05, time * 0.035)).r;
|
||||
// Fog noise — 8-10s breathe cycle, ±0.05 symmetric around baseline
|
||||
float noise_val = texture(noise_tex, tile * 0.03 + vec2(time * 0.11, time * 0.07)).r;
|
||||
float fog_alpha = 0.30 + (noise_val * 2.0 - 1.0) * 0.05; // 0.25-0.35
|
||||
|
||||
// Light fog: alpha 0.25-0.35 (near cone gradient)
|
||||
float light_fog_alpha = 0.30 + (noise_fast * 2.0 - 1.0) * 0.05;
|
||||
// Deep fog: alpha 0.55-0.70 (far from cone, EXP_EXPLORED)
|
||||
float deep_fog_alpha = 0.625 + (noise_slow * 2.0 - 1.0) * 0.075;
|
||||
|
||||
// Blend deep <-> light fog by proximity to cone:
|
||||
// vis=0 (far from cone) → deep_factor=1 → deep fog color + alpha
|
||||
// vis=0.3 (cone gradient) → deep_factor=0 → light fog color + alpha
|
||||
// vis=0.85+ (inside cone) → clarity=1 → transparent (clear)
|
||||
float deep_factor = 1.0 - smoothstep(0.0, 0.30, vis);
|
||||
float fog_alpha = mix(light_fog_alpha, deep_fog_alpha, deep_factor);
|
||||
|
||||
// Zone temperature tint (D-059/D-046/D-077): deep fog color = zone tint
|
||||
// Zone temperature tint (D-046/D-077): subtle warm/cool/neutral per zone
|
||||
vec3 zone_tint = texture(zone_tint_tex, tex_uv).rgb;
|
||||
vec3 fog_color = mix(DARK_OVERLAY, zone_tint, deep_factor);
|
||||
|
||||
// Clarity ramp: transparent inside cone, light fog at edges and beyond
|
||||
float clarity = smoothstep(0.0, 0.85, vis);
|
||||
float alpha = mix(fog_alpha, 0.0, clarity);
|
||||
vec3 color = mix(zone_tint, vec3(0.0), clarity);
|
||||
|
||||
// Explored/unexplored boundary: squared fade hides tile content edges
|
||||
float exp_fade = smoothstep(0.3, 1.0, explored);
|
||||
exp_fade *= exp_fade; // Steeper: fog stays opaque near content edge
|
||||
alpha = mix(1.0, alpha, exp_fade);
|
||||
color = mix(UNEXPLORED_COLOR, color, exp_fade);
|
||||
```
|
||||
|
||||
**Zone temperature palette (D-046):**
|
||||
@@ -215,11 +219,13 @@ Per tick (in _process or on snapshot signal):
|
||||
|
||||
| Component | Budget | Estimate | Notes |
|
||||
|-----------|--------|----------|-------|
|
||||
| Visibility texture upload | 0.1ms | ~0.05ms | 400 pixels via set_pixel() |
|
||||
| Exploration texture update | 0.1ms | ~0.05ms | Incremental — only changed tiles |
|
||||
| Fragment shader (1080p) | 0.5ms | ~0.2ms | Single full-screen pass, simple math |
|
||||
| CPU Gaussian blur (1×, 40×40) | 0.2ms | ~0.1ms | Separable, sigma=2.0, radius=4 (vis: 1 pass, exp: 2 passes) |
|
||||
| Image.resize C++ (40→160) | 0.1ms | ~0.05ms | INTERPOLATE_BILINEAR, 2× textures |
|
||||
| Image.convert R8→RGBA8 | 0.1ms | ~0.02ms | GL compat bilinear requires RGBA8 |
|
||||
| Texture upload (RGBA8 160×160) | 0.2ms | ~0.1ms | 2× textures, ~200KB total |
|
||||
| Fragment shader (1080p) | 0.2ms | ~0.05ms | 2 texture reads/px (was 98 with GPU blur) |
|
||||
| Fog entity sprites | 0.2ms | ~0.05ms | 0-15 sprites, trivial draw calls |
|
||||
| **Total** | **<1ms** | **~0.35ms** | Well within D-059 budget |
|
||||
| **Total** | **<1ms** | **~0.37ms** | Well within D-059 budget |
|
||||
|
||||
## Files to Create
|
||||
|
||||
|
||||
Reference in New Issue
Block a user