272 lines
18 KiB
Text
272 lines
18 KiB
Text
# ============================================================================
|
|
# daylight.ludic — a time of day over the HDRI sky. The photograph is one late
|
|
# morning; the game wants a whole day. The sun's direction and colour follow a
|
|
# simple solar arc from the time (`daylight_set`), the sky image turns to keep
|
|
# its disc under that sun, the image-based light is scaled toward a deep-blue
|
|
# night (`u_ibl_scale`), and after dusk the light becomes a moon so the world
|
|
# still has shadows and form. A campfire is the one point light (`u_fire_*`).
|
|
# The convolved sky maps are rebuilt only when the sky has turned far from the
|
|
# angle they were baked at; the height-field shadow rebakes as the sun moves.
|
|
# ============================================================================
|
|
|
|
# The moon's place in its month, 0 new .. 0.5 full .. 1 new again. It decides the disc's
|
|
# terminator, how much light reaches the ground, and where in the sky it rides: a full
|
|
# moon is opposite the sun and rises at sunset, a new one travels with it.
|
|
|
|
function daylight_init(render3d_st: mut Render3dState) -> void {
|
|
render3d_st.day_ibl = v3_new(1.0, 1.0, 1.0)
|
|
render3d_st.day_sun_base = v3_new(render3d_st.sun_color[0], render3d_st.sun_color[1], render3d_st.sun_color[2])
|
|
render3d_st.fire_pos = v3_new(0.0, -1000.0, 0.0)
|
|
render3d_st.fire_color = v3_new(0.0, 0.0, 0.0)
|
|
render3d_st.day_moon_dir = v3_new(0.0, 1.0, 0.0)
|
|
render3d_st.hand_pos = v3_new(0.0, -1000.0, 0.0); render3d_st.hand_color = v3_new(0.0, 0.0, 0.0); render3d_st.hand_dir = v3_new(0.0, 0.0, -1.0); render3d_st.hand_cone = -2.0; render3d_st.hand_reach = 12.0
|
|
render3d_st.day_light = 1.0
|
|
}
|
|
|
|
# Start the clock: the scene as tuned (sky yaw `yaw0`) is the photograph's hour `hour0`;
|
|
# the sun rises and sets toward `set_yaw` (the direction it should be in at 19:00).
|
|
function daylight_start(render3d_st: mut Render3dState, yaw0: float, hour0: float, set_yaw: float) -> void {
|
|
render3d_st.day_yaw0 = yaw0; render3d_st.day_hour0 = hour0
|
|
render3d_st.day_az0 = Math.atan2(-render3d_st.sun_dir[0], -render3d_st.sun_dir[2])
|
|
render3d_st.day_sky_baked = yaw0
|
|
# which way does the sun travel? the way that puts it nearest `set_yaw` at 19:00
|
|
let step = (19.0 - hour0) * Math.deg_to_rad(15.0)
|
|
let da = Math.abs(day_wrap(render3d_st.day_az0 + step - set_yaw))
|
|
let db = Math.abs(day_wrap(render3d_st.day_az0 - step - set_yaw))
|
|
render3d_st.day_dir = 1.0
|
|
if db < da { render3d_st.day_dir = -1.0 }
|
|
render3d_st.day_on = true
|
|
render3d_st.day_baked_az = 1000.0
|
|
daylight_set(render3d_st, hour0)
|
|
}
|
|
function day_wrap(a: float) -> float {
|
|
let two_pi = 2.0 * PI
|
|
var d = a
|
|
while d > PI { d = d - two_pi }
|
|
while d < -PI { d = d + two_pi }
|
|
return d
|
|
}
|
|
function smoothf(a: float, b: float, x: float) -> float {
|
|
let t = Math.clamp((x - a) / (b - a), 0.0, 1.0)
|
|
return t * t * (3.0 - 2.0 * t)
|
|
}
|
|
|
|
function daylight_set(render3d_st: mut Render3dState, hours: float) -> void {
|
|
var h = hours % 24.0
|
|
if h < 0.0 { h = h + 24.0 }
|
|
render3d_st.day_hours = h
|
|
# the arc: up at 5:30, highest (about 57 degrees) at 12:45, down at 20:00
|
|
let t = (h - 5.5) / 14.5 * PI
|
|
let el = Math.deg_to_rad(-6.0 + 63.0 * Math.sin(t))
|
|
let az = render3d_st.day_az0 + (h - render3d_st.day_hour0) * Math.deg_to_rad(15.0) * render3d_st.day_dir
|
|
render3d_st.day_az = az; render3d_st.day_el = el
|
|
let d = smoothf(Math.deg_to_rad(-8.0), Math.deg_to_rad(12.0), el)
|
|
render3d_st.day_light = d
|
|
# the sun, warm and dim near the horizon; past dusk, the moon from across the sky
|
|
var laz = az; var lel = Math.max(el, Math.deg_to_rad(3.0))
|
|
var warm_r = 1.0; var warm_g = 1.0; var warm_b = 1.0
|
|
let low = smoothf(0.0, Math.deg_to_rad(24.0), el)
|
|
warm_g = Math.lerp(0.55, 1.0, low); warm_b = Math.lerp(0.28, 1.0, low)
|
|
# an overcast sky: the sun goes diffuse and grey, a lightning flash brings it back white
|
|
let oc = Math.clamp(render3d_st.day_overcast, 0.0, 1.0)
|
|
let sunk = 1.0 - 0.92 * oc + 2.5 * render3d_st.day_flash
|
|
var sr = render3d_st.day_sun_base[0] * (d * warm_r * sunk)
|
|
var sg = render3d_st.day_sun_base[1] * (d * warm_g * sunk)
|
|
var sb = render3d_st.day_sun_base[2] * (d * warm_b * sunk)
|
|
# The moon rides a lag behind the sun that is its phase: full is opposite (half a turn),
|
|
# new is alongside. Its elevation follows the same arc, offset by the same amount, so a
|
|
# full moon rises as the sun sets and a new moon is up all day and invisible.
|
|
# The moon is where the sun was `lag` of a day ago: at full that is half a day, so it
|
|
# rises as the sun sets; at new it is alongside the sun and up all day, invisible. The
|
|
# sign matters — a waxing crescent has to set AFTER the sun, not before it.
|
|
let moon_lag = 2.0 * PI * render3d_st.day_moon_phase
|
|
let maz = az - moon_lag * render3d_st.day_dir
|
|
let mel = Math.deg_to_rad(-6.0 + 63.0 * Math.sin(t - moon_lag))
|
|
let mce = Math.cos(mel)
|
|
v3_set(render3d_st.day_moon_dir, -(Math.sin(maz) * mce), Math.sin(mel), -(Math.cos(maz) * mce))
|
|
render3d_st.day_moon = false
|
|
if el < Math.deg_to_rad(-7.0) {
|
|
render3d_st.day_moon = true
|
|
laz = maz
|
|
lel = Math.clamp(mel, Math.deg_to_rad(6.0), Math.deg_to_rad(70.0))
|
|
let m = smoothf(Math.deg_to_rad(-7.0), Math.deg_to_rad(-16.0), el)
|
|
# what the moon is worth on the ground, by how much of it is lit. A new moon is a
|
|
# properly dark night, which is what makes a torch and a lantern matter.
|
|
let up = smoothf(Math.deg_to_rad(-4.0), Math.deg_to_rad(8.0), mel)
|
|
let lit = m * up * (0.06 + 0.94 * render3d_st.day_moon_illum)
|
|
sr = render3d_st.day_sun_base[0] * (0.0130 * lit)
|
|
sg = render3d_st.day_sun_base[1] * (0.0165 * lit)
|
|
sb = render3d_st.day_sun_base[2] * (0.0250 * lit)
|
|
}
|
|
let ce = Math.cos(lel)
|
|
v3_set(render3d_st.sun_dir, -(Math.sin(laz) * ce), Math.sin(lel), -(Math.cos(laz) * ce))
|
|
v3_set(render3d_st.sun_color, sr, sg, sb)
|
|
# the sky's light: full by day, a deep blue by night, amber through the dusk
|
|
let dusk = smoothf(Math.deg_to_rad(-10.0), Math.deg_to_rad(2.0), el) * (1.0 - smoothf(Math.deg_to_rad(2.0), Math.deg_to_rad(18.0), el))
|
|
# a full moon lifts the night's own ambient nearly threefold; a new moon leaves it alone
|
|
var moonlit = 1.0
|
|
if render3d_st.day_moon { moonlit = 1.0 + 1.8 * render3d_st.day_moon_illum }
|
|
v3_set(render3d_st.day_ibl, Math.lerp(0.020 * moonlit, 1.0, d), Math.lerp(0.026 * moonlit, 1.0, d), Math.lerp(0.045 * moonlit, 1.0, d))
|
|
render3d_st.day_ibl[0] = render3d_st.day_ibl[0] * (1.0 + 0.35 * dusk)
|
|
render3d_st.day_ibl[2] = render3d_st.day_ibl[2] * (1.0 - 0.25 * dusk)
|
|
# clouds: less light, and greyer (the blue and the warmth both fade)
|
|
let grey = (render3d_st.day_ibl[0] + (render3d_st.day_ibl[1] + render3d_st.day_ibl[2])) * 0.3333 + 0.6 * render3d_st.day_flash
|
|
let dim = 1.0 - 0.55 * oc
|
|
for i in 0 .. 3 { render3d_st.day_ibl[i] = Math.lerp(render3d_st.day_ibl[i], grey, 0.7 * oc) * dim }
|
|
# ---- the air ---------------------------------------------------------------------------
|
|
# Aerial perspective is a CURVE, not the one constant it was. A low sun is shining through
|
|
# far more air than a high one, and it is shining ALONG the ground rather than down onto it,
|
|
# so three things move together with its elevation: how much air there is, how hard that air
|
|
# scatters the sun forward, and how low in the valley it lies. `lowsun` peaks at the horizon
|
|
# and falls away on both sides - it has to fall away BELOW it too, or the middle of the night
|
|
# gets a dawn's haze with no dawn to justify it. Overcast thickens the air and flattens the
|
|
# scatter, because a grey sky has no disc to scatter from. The player's slider still
|
|
# multiplies the result, so nobody loses the setting they chose.
|
|
if render3d_st.day_fog_base == 0.0 { render3d_st.day_fog_base = render3d_st.r3d_fog_density }
|
|
let fog_rise = smoothf(Math.deg_to_rad(-12.0), Math.deg_to_rad(1.0), el)
|
|
let fog_high = smoothf(Math.deg_to_rad(2.0), Math.deg_to_rad(26.0), el)
|
|
let lowsun = fog_rise * (1.0 - fog_high)
|
|
var dens = render3d_st.day_fog_base * (1.0 + 1.5 * lowsun)
|
|
dens = dens * (1.0 + 1.2 * oc)
|
|
render3d_st.r3d_fog_density = dens * render3d_st.day_fog_mul * render3d_st.r3d_fog_scale
|
|
# how fast the haze thins with height: a settled morning's lies IN the valley, a noon sky is
|
|
# thin all the way up, so the falloff rises as the sun drops
|
|
render3d_st.r3d_fog_falloff = 0.002 * (1.0 + 1.6 * lowsun)
|
|
# the glow a ridge is silhouetted against when you look into a low sun
|
|
render3d_st.r3d_fog_inscatter = (0.012 + 0.16 * lowsun) * (1.0 - 0.7 * oc)
|
|
# and distance takes colour away at every hour, harder under cloud
|
|
# 1.9 was tuned on a valley whose rock was grey anyway. Maroon's air is thin, dry and at
|
|
# 2900 m, and the Bells are only a couple of kilometres from the lake - in the photograph
|
|
# everybody knows, they are still plainly RED at that distance. Desaturating them to a pale
|
|
# grey-pink is physically defensible and loses the one thing the range is named for, so the
|
|
# basin's own air gets a gentler figure and overcast still takes colour away faster.
|
|
render3d_st.r3d_fog_desat = 1.15 + 0.7 * oc
|
|
# ---- the grade -------------------------------------------------------------------------
|
|
# The look of an hour is not only how much air is in front of the mountain; it is what colour
|
|
# the light is and what the shadows are filled with. Noon is the case worth naming: direct
|
|
# sun is warm-white and the ONLY thing filling a midday shadow is a blue sky, so a midday
|
|
# frame wants a cool, lifted shadow and a hard contrast between it and the lit ground. Dawn
|
|
# and dusk are the opposite - a warm low sun, warm shadow fill off the whole sky, and less
|
|
# contrast because the light is coming through so much air. Overcast flattens and drains both.
|
|
# `night` is deliberately NOT `1 - d`: d is already falling while the sun is still on the
|
|
# horizon, so the two curves would fight and the warmest minute of the day would come out
|
|
# half-cooled. It only begins under the horizon.
|
|
let night = 1.0 - smoothf(Math.deg_to_rad(-14.0), Math.deg_to_rad(-4.0), el)
|
|
let hi = fog_high
|
|
render3d_st.post_wb_r = 1.02 + (0.10 * lowsun - (0.03 * hi + 0.06 * night))
|
|
render3d_st.post_wb_g = 1.0 + 0.012 * lowsun
|
|
render3d_st.post_wb_b = 0.97 + (0.055 * hi + 0.13 * night - 0.09 * lowsun)
|
|
# the shadows' floor: warm and open into a low sun, blue at noon, cold and crushed at night
|
|
render3d_st.post_lift_r = 0.004 + 0.013 * lowsun - 0.002 * (hi + night)
|
|
render3d_st.post_lift_g = 0.004 + 0.008 * lowsun - 0.001 * night
|
|
render3d_st.post_lift_b = 0.012 + (0.004 * lowsun + 0.013 * hi)
|
|
# Gain is left alone on purpose. It looks like a highlight control and is not: the grade is
|
|
# `c * gain + lift * (1 - c)`, so warming the gain warms the WHOLE frame, and warming it at
|
|
# noon undid the cool white balance above and turned one o'clock yellower than seven in the
|
|
# morning - the opposite of the thing this grade exists to do. Midday's punch comes from
|
|
# contrast, and midday's colour from a cool balance over a blue shadow.
|
|
render3d_st.post_gain_r = 0.99
|
|
render3d_st.post_gain_g = 0.995
|
|
render3d_st.post_gain_b = 1.0
|
|
render3d_st.post_contrast = 1.12 + 0.11 * hi - (0.17 * oc + 0.06 * night)
|
|
render3d_st.post_saturation = 1.04 + 0.12 * lowsun - (0.20 * oc + 0.12 * night)
|
|
|
|
# The visible sky is relit by the hour (sky.frag). It fades out under the horizon, where the
|
|
# night's own tint, stars and moon take over, and it eases off under heavy cloud - a relit
|
|
# overcast is still overcast, and driving a clear-sky model hard through one paints a blue
|
|
# zenith onto a grey day.
|
|
render3d_st.r3d_sky_relight = smoothf(Math.deg_to_rad(-10.0), Math.deg_to_rad(1.0), el) * (1.0 - 0.75 * oc)
|
|
|
|
# ---- what is IN the air -------------------------------------------------------------
|
|
# The volumetric march (post.ludic) needs the same story the analytic fog tells, or the
|
|
# shafts and the haze disagree. Density rides the sun's elevation like everything else; the
|
|
# MIST is separate and is the thing a valley actually does - a shallow layer that forms in
|
|
# the cold at either end of the day, lies ON the ground rather than filling the basin, and
|
|
# burns off by mid-morning. Cloud thickens the air and kills the shafts, because a shaft
|
|
# needs a disc to come from.
|
|
render3d_st.post_vol_density = (0.00030 + 0.00070 * lowsun) * (1.0 - 0.55 * oc)
|
|
render3d_st.post_vol_mist = 0.40 * lowsun * (1.0 - 0.4 * oc)
|
|
render3d_st.post_vol_falloff = 0.006 + 0.004 * lowsun
|
|
|
|
# R3D_NOAIR=1: the air as it was before any of the above - one density, one falloff, the
|
|
# inscatter the shader used to hard-code, and no distance desaturation at all. It is here
|
|
# so a before-and-after can be shot from ONE binary at one hour, which is the only kind of
|
|
# comparison worth looking at, and it joins R3D_NOCLOUD / R3D_NOSHADOW / R3D_NOGI.
|
|
if r3d_env_has(render3d_st, "R3D_NOAIR") {
|
|
render3d_st.r3d_fog_density = render3d_st.day_fog_base * render3d_st.day_fog_mul * render3d_st.r3d_fog_scale
|
|
render3d_st.r3d_fog_falloff = 0.002
|
|
render3d_st.r3d_fog_inscatter = 0.02
|
|
render3d_st.r3d_fog_desat = 0.0
|
|
render3d_st.post_wb_r = 1.02; render3d_st.post_wb_g = 1.0; render3d_st.post_wb_b = 0.97
|
|
render3d_st.post_lift_r = 0.004; render3d_st.post_lift_g = 0.004; render3d_st.post_lift_b = 0.012
|
|
render3d_st.post_gain_r = 0.99; render3d_st.post_gain_g = 0.995; render3d_st.post_gain_b = 1.0
|
|
render3d_st.post_contrast = 1.12; render3d_st.post_saturation = 1.04
|
|
render3d_st.r3d_sky_relight = 0.0
|
|
render3d_st.post_vol_density = 0.0; render3d_st.post_vol_mist = 0.0
|
|
}
|
|
# exposure: auto-exposure must not turn the night into day
|
|
# the ceiling has to move with the moon or auto-exposure eats the difference between a
|
|
# full-moon night and a new-moon one
|
|
var night_max = 4.5
|
|
if render3d_st.day_moon { night_max = 4.5 + 3.5 * render3d_st.day_moon_illum }
|
|
render3d_st.post_exposure_max = Math.lerp(night_max, 20.0, d)
|
|
# the visible sky turns with the sun (cheap); its convolutions rebake when far off
|
|
let sky_yaw_now = render3d_st.day_yaw0 + (h - render3d_st.day_hour0) * Math.deg_to_rad(15.0) * render3d_st.day_dir
|
|
sky_set_rot(render3d_st, sky_yaw_now)
|
|
if Math.abs(day_wrap(sky_yaw_now - render3d_st.day_sky_baked)) > Math.deg_to_rad(35.0) and d > 0.05 {
|
|
render3d_st.day_sky_baked = sky_yaw_now
|
|
sky_precompute(render3d_st)
|
|
}
|
|
# the terrain's baked shadow follows the light in steps
|
|
if Math.abs(day_wrap(laz - render3d_st.day_baked_az)) > Math.deg_to_rad(4.0) or Math.abs(lel - render3d_st.day_baked_el) > Math.deg_to_rad(3.0) {
|
|
render3d_st.day_baked_az = laz; render3d_st.day_baked_el = lel
|
|
render3d_st.day_gen += 1
|
|
}
|
|
}
|
|
|
|
# where the moon is in its month; the game advances this each morning
|
|
function daylight_moon(render3d_st: mut Render3dState, phase: float) -> void {
|
|
var p = phase % 1.0
|
|
if p < 0.0 { p = p + 1.0 }
|
|
render3d_st.day_moon_phase = p
|
|
# illuminated fraction: (1 - cos(2 pi p)) / 2, which is 0 at new and 1 at full
|
|
render3d_st.day_moon_illum = (1.0 - Math.cos(2.0 * PI * p)) * 0.5
|
|
daylight_set(render3d_st, render3d_st.day_hours)
|
|
}
|
|
|
|
# the weather over the valley: overcast 0..1, a fog multiplier, a lightning flash 0..1
|
|
function daylight_weather(render3d_st: mut Render3dState, overcast: float, fog_mul: float, flash: float) -> void {
|
|
render3d_st.day_overcast = overcast; render3d_st.day_fog_mul = fog_mul; render3d_st.day_flash = flash
|
|
}
|
|
# the campfire: a point light at (x, y, z) of `strength` (0 = out)
|
|
function daylight_fire(render3d_st: Render3dState, x: float, y: float, z: float, strength: float) -> void {
|
|
v3_set(render3d_st.fire_pos, x, y, z)
|
|
v3_set(render3d_st.fire_color, 9.0 * strength, 4.6 * strength, 1.4 * strength)
|
|
}
|
|
|
|
# the light in the hand: a point light (cone < -1) or a cone along dir (cone = cos half-angle)
|
|
# A torch or a flashlight in the hand. `reach` is how far it carries, in metres: the
|
|
# falloff is a gentle power out to it and nothing past it (lighting.glsl handLight), which
|
|
# is what a pool of firelight looks like. It used to be a windowed inverse square with the
|
|
# window and the scale both hard-coded, so every hand light in every game had the reach of
|
|
# a candle whatever it was meant to be.
|
|
function daylight_hand(render3d_st: mut Render3dState, x: float, y: float, z: float, dx: float, dy: float, dz: float, cone: float, reach: float, r: float, g: float, b: float) -> void {
|
|
v3_set(render3d_st.hand_pos, x, y, z); v3_set(render3d_st.hand_dir, dx, dy, dz); render3d_st.hand_cone = cone
|
|
v3_set(render3d_st.hand_color, r, g, b)
|
|
render3d_st.hand_reach = reach
|
|
}
|
|
function daylight_bind(render3d_st: mut Render3dState, prog: int) -> void {
|
|
u_v3(render3d_st, gpu_uniform(render3d_st, prog, "u_hand_pos"), render3d_st.hand_pos)
|
|
u_v3(render3d_st, gpu_uniform(render3d_st, prog, "u_hand_color"), render3d_st.hand_color)
|
|
u_v3(render3d_st, gpu_uniform(render3d_st, prog, "u_hand_dir"), render3d_st.hand_dir)
|
|
u_f(render3d_st, gpu_uniform(render3d_st, prog, "u_hand_cone"), render3d_st.hand_cone)
|
|
u_f(render3d_st, gpu_uniform(render3d_st, prog, "u_hand_reach"), render3d_st.hand_reach)
|
|
u_v3(render3d_st, gpu_uniform(render3d_st, prog, "u_ibl_scale"), render3d_st.day_ibl)
|
|
u_v3(render3d_st, gpu_uniform(render3d_st, prog, "u_moon_dir"), render3d_st.day_moon_dir)
|
|
u_f(render3d_st, gpu_uniform(render3d_st, prog, "u_moon_phase"), render3d_st.day_moon_phase)
|
|
u_f(render3d_st, gpu_uniform(render3d_st, prog, "u_moon_illum"), render3d_st.day_moon_illum)
|
|
u_f(render3d_st, gpu_uniform(render3d_st, prog, "u_moon_haze"), render3d_st.day_overcast)
|
|
u_f(render3d_st, gpu_uniform(render3d_st, prog, "u_daylight"), render3d_st.day_light)
|
|
u_v3(render3d_st, gpu_uniform(render3d_st, prog, "u_fire_pos"), render3d_st.fire_pos)
|
|
u_v3(render3d_st, gpu_uniform(render3d_st, prog, "u_fire_color"), render3d_st.fire_color)
|
|
}
|