// AirDef effects: a post pass over the world (render.set-post, AirDef fork). // Blasts are noise volumes marched along the view ray (fireball turning into a smoke // column), with a flash, a shock wave that bends the light and heat haze; engine // flames and muzzle flashes glow. Everything is placed in the world and hidden by // what stands in front of it (the world's depth). // // frame.params (vec4): // [0] now (mod ticks), blasts, lights, - // [1 + 2i], [2 + 2i] blast i: x, y, z, size | start tick, life ticks, kind, - // [97 + 2j], [98 + 2j] light j: x, y, z, radius | r, g, b, intensity const BLAST_BASE: i32 = 1; const LIGHT_BASE: i32 = 97; fn hash3(p: vec3) -> f32 { let q = fract(p * 0.3183099 + vec3(0.11, 0.17, 0.13)); let r = q * 17.0; return fract(r.x * r.y * r.z * (r.x + r.y + r.z)); } fn noise3(x: vec3) -> f32 { let i = floor(x); let f = fract(x); let u = f * f * (3.0 - 2.0 * f); let a = mix(hash3(i), hash3(i + vec3(1.0, 0.0, 0.0)), u.x); let b = mix(hash3(i + vec3(0.0, 1.0, 0.0)), hash3(i + vec3(1.0, 1.0, 0.0)), u.x); let c = mix(hash3(i + vec3(0.0, 0.0, 1.0)), hash3(i + vec3(1.0, 0.0, 1.0)), u.x); let d = mix(hash3(i + vec3(0.0, 1.0, 1.0)), hash3(i + vec3(1.0, 1.0, 1.0)), u.x); return mix(mix(a, b, u.y), mix(c, d, u.y), u.z); } fn fbm(p: vec3) -> f32 { var a = 0.5; var s = 0.0; var q = p; for (var i = 0; i < 3; i++) { s += a * noise3(q); q = q * 2.03 + vec3(1.7, 9.2, 3.1); a *= 0.5; } return s; } // The ray (from the camera, along d) through a sphere: entry and exit distances. fn ray_sphere(d: vec3, c: vec3, r: f32) -> vec2 { let b = dot(-c, d); let k = dot(c, c) - r * r; let h = b * b - k; if h < 0.0 { return vec2(-1.0, -1.0); } let s = sqrt(h); return vec2(-b - s, -b + s); } // The screen size (pixels) of a world radius at a world point. fn screen_radius(world: vec3, radius: f32) -> f32 { let right = (frame.view_inverse * vec4(1.0, 0.0, 0.0, 0.0)).xyz; let a = project(world); let b = project(world + right * radius); return length((b.xy - a.xy) * frame.resolution.xy); } fn now() -> f32 { return frame.params[0].x + frame.time.y; } // Fire's colour from its heat (0 cold soot .. 1 white-hot). fn fire(heat: f32) -> vec3 { let h = clamp(heat, 0.0, 1.0); let ember = vec3(0.35, 0.05, 0.01); let orange = vec3(1.6, 0.55, 0.12); let white = vec3(3.0, 2.4, 1.5); return mix(mix(ember, orange, smoothstep(0.0, 0.5, h)), white, smoothstep(0.6, 1.0, h)); } fn post(uv: vec2, pixel: vec2) -> vec4 { let t_now = now(); let blasts = i32(frame.params[0].y); let lights = i32(frame.params[0].z); let dir = view_dir(uv); let px = uv * frame.resolution.xy; // 1. Shock waves and heat haze bend where the world is sampled. var offset = vec2(0.0); for (var i = 0; i < blasts; i++) { let a = frame.params[BLAST_BASE + 2 * i]; let b = frame.params[BLAST_BASE + 2 * i + 1]; let age = t_now - b.x; if age < 0.0 { continue; } let centre = a.xyz; let p = project(centre); if p.z <= 0.5 { continue; } let to = px - p.xy * frame.resolution.xy; let dist = length(to); // The shock: a ring racing out, fading in a second. if age < 24.0 { let ring = screen_radius(centre, age * 3.2 * (0.6 + a.w * 0.1)); let width = 6.0 + ring * 0.08; let x = (dist - ring) / width; let strength = (1.0 - age / 24.0) * min(a.w / 4.0, 2.0) * 10.0; offset += normalize(to + vec2(1e-4)) * exp(-x * x) * x * strength * frame.resolution.zw; } // Heat haze over a hot fireball. let heat = 1.0 - smoothstep(0.0, 0.5, age / b.y); let r = screen_radius(centre, a.w * 2.0); if heat > 0.0 && dist < r { let n = noise3(vec3(px * 0.04, t_now * 0.35)) - 0.5; offset += vec2(n, -abs(n)) * heat * (1.0 - dist / r) * 6.0 * frame.resolution.zw; } } let suv = clamp(uv + offset, vec2(0.0), vec2(1.0)); var color = scene(suv); let wall = scene_distance(suv); // 1b. Fire lights the land and the vehicles: blasts and flames as point lights on what // the pixel sees, much stronger at night. let night = clamp(0.35 - frame.time.z * 1.8, 0.0, 1.0); let strength = mix(0.35, 2.2, night); // Under the HD lighting (params[0].w) the engine lights the world from the same lights. if wall < 1.0e5 && frame.params[0].w < 0.5 { let p = dir * wall; var light = vec3(0.0); for (var i = 0; i < blasts; i++) { let a = frame.params[BLAST_BASE + 2 * i]; let b = frame.params[BLAST_BASE + 2 * i + 1]; let age = t_now - b.x; if age < 0.0 { continue; } let heat = exp(-age / max(b.y * 0.12, 1.0)); let flash = exp(-age * 0.5) * 3.0; let d = length(p - (a.xyz - frame.camera.xyz)) / (a.w * 3.0); light += vec3(1.0, 0.55, 0.2) * (heat + flash) * a.w * 0.6 / (1.0 + d * d * 4.0); } for (var j = 0; j < lights; j++) { let a = frame.params[LIGHT_BASE + 2 * j]; let b = frame.params[LIGHT_BASE + 2 * j + 1]; let d = length(p - (a.xyz - frame.camera.xyz)) / max(a.w * 6.0, 1.0); light += b.rgb * b.w / (1.0 + d * d * 6.0); } color += color * light * strength + light * 0.02 * night; } // 2. Fireballs and their smoke, marched front to back. var glow = vec3(0.0); var trans = 1.0; var lit = vec3(0.0); let sun = max(frame.time.z, 0.15); for (var i = 0; i < blasts; i++) { let a = frame.params[BLAST_BASE + 2 * i]; let b = frame.params[BLAST_BASE + 2 * i + 1]; let age = t_now - b.x; if age < 0.0 { continue; } let life = b.y; let k = clamp(age / life, 0.0, 1.0); let size = a.w; let seed = vec3(a.x * 0.37, a.y * 0.11, a.z * 0.53); // The ball swells fast, then rises and spreads as smoke. let radius = size * (0.3 + 0.9 * (1.0 - exp(-age / 3.0))) * (1.0 + k * 0.9); let centre = a.xyz - frame.camera.xyz + vec3(0.0, k * k * size * 2.2, 0.0); let span = ray_sphere(dir, centre, radius); if span.y <= 0.0 { continue; } let t0 = max(span.x, 0.0); let t1 = min(span.y, wall); if t1 <= t0 { continue; } let heat = 1.0 - smoothstep(0.05, 0.55, k); let fade = 1.0 - smoothstep(0.65, 1.0, k); // Fewer steps for a fireball that is small on screen. let on_screen = radius / max(length(centre), 1.0); let steps = i32(clamp(on_screen * 40.0, 6.0, 14.0)); let ds = (t1 - t0) / f32(steps); for (var s = 0; s < steps; s++) { if trans < 0.02 { break; } let p = dir * (t0 + (f32(s) + 0.5) * ds); let local = (p - centre) / radius; let r = length(local); let n = fbm(local * 2.4 + seed + vec3(0.0, -age * 0.06, age * 0.02)); let shape = smoothstep(1.0, 0.25, r + (n - 0.5) * 1.1); if shape <= 0.0 { continue; } let density = shape * (1.2 + n * 2.0) * fade; let absorb = 1.0 - exp(-density * ds * 1.4 / max(radius * 0.25, 0.5)); // Hot inside, soot outside; smoke lit from above by the sky. let core = heat * (1.0 - r) * (0.6 + n); let smoke = vec3(0.10, 0.095, 0.09) * (0.5 + 0.8 * sun * (0.5 + local.y * 0.5)); let c = mix(smoke, fire(core * 1.6), clamp(core * 2.2, 0.0, 1.0)); lit += trans * absorb * c; trans *= 1.0 - absorb; } // Light thrown round by the fire. let d = length(centre); glow += vec3(1.0, 0.5, 0.15) * heat * heat * size * 0.05 / (1.0 + d * 0.03); } color = color * trans + lit; // 3. Flashes: a bright bloom at the blast and the whole view lit up for a moment. for (var i = 0; i < blasts; i++) { let a = frame.params[BLAST_BASE + 2 * i]; let b = frame.params[BLAST_BASE + 2 * i + 1]; let age = t_now - b.x; if age < 0.0 || age > 10.0 { continue; } let p = project(a.xyz); if p.z <= 0.5 { continue; } let visible = select(0.25, 1.0, scene_distance(p.xy) > p.z - a.w); let f = exp(-age * 0.7) * min(a.w / 4.0, 2.5) * visible; let r = screen_radius(a.xyz, a.w * 2.5) + 20.0; let dd = length(px - p.xy * frame.resolution.xy) / r; color += vec3(1.0, 0.85, 0.6) * f * (exp(-dd * dd * 3.0) * 2.5 + exp(-dd * 0.8) * 0.25); color += vec3(1.0, 0.8, 0.55) * f * 0.12 / (1.0 + p.z * 0.01); } // 4. Glows: engine flames and muzzle flashes. for (var j = 0; j < lights; j++) { let a = frame.params[LIGHT_BASE + 2 * j]; let b = frame.params[LIGHT_BASE + 2 * j + 1]; let p = project(a.xyz); if p.z <= 0.3 { continue; } if scene_distance(p.xy) < p.z - a.w * 1.5 { continue; } let r = screen_radius(a.xyz, a.w) + 3.0; let dd = length(px - p.xy * frame.resolution.xy) / r; let flicker = 0.85 + 0.15 * noise3(vec3(a.xyz * 0.7 + vec3(t_now * 1.3))); color += b.rgb * b.w * flicker * (exp(-dd * dd * 4.0) * 1.2 + exp(-dd * 1.2) * 0.18); } color += glow * 0.3; // Soft roll-off so bright fire stays coloured instead of clipping flat. color = color / (1.0 + max(color - vec3(1.0), vec3(0.0)) * 0.5); return vec4(color, 1.0); }