ProceduralSkyMaterial varies wildly in color and brightness depending on gaze orientation

[Baplar]

Description

As long as the Sun is in a fixed position in the sky, the ProceduralSkyMaterial should look stable regardless of where you look. However, this is not the case currently: looking up or down drastically alters the color of the sky.

Repro steps

1. Create a grid space
2. Fly and delete the ground to see below you (optional)
3. Move your head up or down

Video_2026-05-14_01-05-42.mp4

Expected vs observed behavior

Expected: The sky is safe and stable.

Observed: The sky looks back at you and reacts to your gaze’s orientation.

Logs / platform

2026-05-13_23-04-14.log

[ColinTimBarndt]

evaluate_scattering is the problematic function. c_in flashes white at exactly +/- 30° (eye_ray.y +/- 0.5) from the horizon and c_out goes from dark gray (up) to light gray (horizontal) to white (down) in discrete steps.

Renderide/crates/renderide/shaders/modules/skybox/procedural.wgsl

Lines 127 to 193 in 81668f9

	fn evaluate_scattering(
	eye_ray: vec3<f32>,
	sun_dir: vec3<f32>,
	inv_wavelength: vec3<f32>,
	krayleigh: f32,
	) -> ScatteringOutput {
	let kkr_esun = krayleigh * KSUN_BRIGHTNESS;
	let kkr_4pi = krayleigh * 4.0 * PI;
	let camera_pos = vec3<f32>(0.0, INNER_RADIUS + CAMERA_HEIGHT, 0.0);
	var c_in: vec3<f32>;
	var c_out: vec3<f32>;
	if (eye_ray.y >= 0.0) {
	let far = sqrt(OUTER_RADIUS_SQ + INNER_RADIUS_SQ * eye_ray.y * eye_ray.y - INNER_RADIUS_SQ)
	- INNER_RADIUS * eye_ray.y;
	let height = INNER_RADIUS + CAMERA_HEIGHT;
	let depth_init = exp(KSCALE_OVER_SCALE_DEPTH * (-CAMERA_HEIGHT));
	let start_angle = dot(eye_ray, camera_pos) / height;
	let start_offset = depth_init * scale_factor(start_angle);
	let sample_length = far / KSAMPLES;
	let scaled_length = sample_length * KSCALE;
	let sample_ray = eye_ray * sample_length;
	var sample_point = camera_pos + sample_ray * 0.5;
	var front_color = vec3<f32>(0.0);
	let s0 = scattering_inscatter_step(
	sample_point, eye_ray, sun_dir, inv_wavelength, kkr_4pi, start_offset, scaled_length,
	);
	front_color = front_color + s0.contribution;
	sample_point = sample_point + sample_ray;
	let s1 = scattering_inscatter_step(
	sample_point, eye_ray, sun_dir, inv_wavelength, kkr_4pi, start_offset, scaled_length,
	);
	front_color = front_color + s1.contribution;
	c_in = front_color * (inv_wavelength * kkr_esun);
	c_out = front_color * KKM_ESUN;
	} else {
	let far = (-CAMERA_HEIGHT) / min(-0.001, eye_ray.y);
	let pos = camera_pos + far * eye_ray;
	let depth = exp((-CAMERA_HEIGHT) * (1.0 / KSCALE_DEPTH));
	let camera_angle = dot(-eye_ray, pos);
	let light_angle = dot(sun_dir, pos);
	let camera_scale = scale_factor(camera_angle);
	let light_scale = scale_factor(light_angle);
	let camera_offset = depth * camera_scale;
	let temp = light_scale + camera_scale;
	let sample_length = far / KSAMPLES;
	let scaled_length = sample_length * KSCALE;
	let sample_ray = eye_ray * sample_length;
	let sample_point = camera_pos + sample_ray * 0.5;
	let g = ground_inscatter_step(
	sample_point, inv_wavelength, kkr_4pi, temp, camera_offset, scaled_length,
	);
	let front_color = g.contribution;
	c_in = front_color * (inv_wavelength * kkr_esun + KKM_ESUN);
	c_out = clamp(g.attenuate, vec3<f32>(0.0), vec3<f32>(1.0));
	}
	return ScatteringOutput(c_in, c_out);
	}

[ColinTimBarndt]

For y>0, the far function is supposed to be smooth like this, no steps:

[ColinTimBarndt]

I've split the original formula:

let far = sqrt(OUTER_RADIUS_SQ + INNER_RADIUS_SQ * eye_ray.y * eye_ray.y - INNER_RADIUS_SQ)
    - INNER_RADIUS * eye_ray.y;

Into:

let far_inner = OUTER_RADIUS_SQ + INNER_RADIUS_SQ * eye_ray.y * eye_ray.y - INNER_RADIUS_SQ;
let far = sqrt(far_inner) - INNER_RADIUS * eye_ray.y;

And far_inner is also misbehaving. It is jumping at eye_ray.y=0.5, but it should look like this:

[ColinTimBarndt]

I've inlined all constants to be sure, and even this misbehaves:

let far_inner = 1.050625 + eye_ray.y * eye_ray.y - 1.0;

I'm going to bed now and will continue looking at this math after work tomorrow. If anyone wants to dissect this further, be my guest.

[Baplar]

The misbehavior may be due to the fact that the interpolation performed by wgpu during the rasterization phase may have caused sharp edges to appear in the topology submitted to the fragment shader.

I have created a branch that behaves much better, by virtue of only providing one giant covering triangle instead of two: #515
With this, the sky no longer flashes at certain angles, it behaves much more like it should!

However, this fix is only part of the equation: the coordinate system conversion between clip and eye spaces seems to be a bit wonky.
For example, the Sun is still difficult to find, and when you do, it creates artifacts along the screen.
I tested the Gradient Skybox material, which has similar issues, and found this: it seems that the coordinate system is somehow rotated 90 degrees to the left in view space.

[ColinTimBarndt]

My hunch was a red herring. The 30° comes from the Desktop FOV being 60° and so when you look up/down 30°, that's when the upper/lower quad vertices switch their sign for eye_ray.y. This means that there is a discontinuity between the logic for the upper and the lower half.

[DoubleStyx]

Should be fixed now with #515.