#version 460
#include "debug.glsl"
#include "utils.glsl"
#include "color_spaces.glsl"

#define GLSL
#include "ray_interop.h"
#undef GLSL

layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;

layout(set = 0, binding = 0, rgba16f) uniform image2D out_dest;

layout(set = 0, binding = 1, rgba8) uniform readonly image2D base_color_a;

layout(set = 0, binding = 2, rgba16f) uniform readonly image2D light_poly_diffuse;
layout(set = 0, binding = 3, rgba16f) uniform readonly image2D light_poly_specular;

layout(set = 0, binding = 4, rgba16f) uniform readonly image2D light_point_diffuse;
layout(set = 0, binding = 5, rgba16f) uniform readonly image2D light_point_specular;
layout(set = 0, binding = 6, rgba16f) uniform readonly image2D emissive;

layout(set = 0, binding = 7, rgba32f) uniform readonly image2D position_t;
layout(set = 0, binding = 8, rgba16f) uniform readonly image2D normals_gs;
layout(set = 0, binding = 9, rgba8) uniform readonly image2D material_rmxx;
layout(set = 0, binding = 10, rgba32f) uniform readonly image2D geometry_prev_position;

layout(set = 0, binding = 11) uniform UBO { UniformBuffer ubo; } ubo;

layout(set = 0, binding = 12, rgba16f) uniform readonly image2D indirect_diffuse;
layout(set = 0, binding = 13, rgba16f) uniform readonly image2D indirect_diffuse_atrous1;
layout(set = 0, binding = 14, rgba16f) uniform readonly image2D indirect_specular;

layout(set = 0, binding = 15, rgba16f) uniform image2D out_temporal_diffuse;
layout(set = 0, binding = 16, rgba16f) uniform image2D prev_temporal_diffuse;

layout(set = 0, binding = 17, rgba16f) uniform image2D out_temporal_specular;
layout(set = 0, binding = 18, rgba16f) uniform image2D prev_temporal_specular;

//#define DEBUG_NOISE
#ifdef DEBUG_NOISE
layout(set = 0, binding = 19) uniform sampler3D blue_noise_texture;
#include "bluenoise.glsl"
#endif

layout(set = 0, binding = 20, rgba16f) uniform readonly image2D legacy_blend;

//layout(set = 0, binding = 21) uniform sampler2D textures[MAX_TEXTURES];

#include "atrous.glsl"

const int INDIRECT_SCALE = 2;

// Blatantly copypasted from https://www.shadertoy.com/view/XsGfWV
vec3 aces_tonemap(vec3 color){
	mat3 m1 = mat3(
		0.59719, 0.07600, 0.02840,
		0.35458, 0.90834, 0.13383,
		0.04823, 0.01566, 0.83777
	);
	mat3 m2 = mat3(
		1.60475, -0.10208, -0.00327,
		-0.53108,  1.10813, -0.07276,
		-0.07367, -0.00605,  1.07602
	);
	vec3 v = m1 * color;
	vec3 a = v * (v + 0.0245786) - 0.000090537;
	vec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;
	//return pow(clamp(m2 * (a / b), 0.0, 1.0), vec3(1.0 / 2.2));
	return clamp(m2 * (a / b), 0.0, 1.0);
}

vec3 reinhard(vec3 color){
	return color / (color + 1.0);
}

vec3 reinhard02(vec3 c, vec3 Cwhite2) {
	return c * (1. + c / Cwhite2) / (1. + c);
}

float normpdf2(in float x2, in float sigma) { return 0.39894*exp(-0.5*x2/(sigma*sigma))/sigma; }
float normpdf(in float x, in float sigma) { return normpdf2(x*x, sigma); }

void readNormals(ivec2 uv, out vec3 geometry_normal, out vec3 shading_normal) {
	const vec4 n = imageLoad(normals_gs, uv);
	geometry_normal = normalDecode(n.xy);
	shading_normal = normalDecode(n.zw);
}

struct Components {
	vec3 direct_diffuse, direct_specular, indirect_diffuse, indirect_specular;
};

Components dontBlurSamples(const ivec2 res, const ivec2 pix) {
	Components c;
	c.direct_diffuse = c.direct_specular = c.indirect_diffuse = c.indirect_specular = vec3(0.);
	const ivec2 p = pix;
	const ivec2 p_indirect = pix / INDIRECT_SCALE;
	c.direct_diffuse += imageLoad(light_point_diffuse, p).rgb;
	c.direct_diffuse += imageLoad(light_poly_diffuse, p).rgb;
	c.indirect_diffuse += imageLoad(indirect_diffuse, p_indirect).rgb;
	c.direct_specular += imageLoad(light_poly_specular, p).rgb;
	c.direct_specular += imageLoad(light_point_specular, p).rgb;
	c.indirect_specular += imageLoad(indirect_specular, p_indirect).rgb;
	return c;
}

#define BOX_BLUR(out, tex, res, center, kernel_range) \
{ \
	const float scale = 1. / pow(float(kernel_range * 2 + 1), 2.); \
	for (int x = -kernel_range; x <= kernel_range; ++x) { \
		for (int y = -kernel_range; y <= kernel_range; ++y) { \
			const ivec2 p = center + ivec2(x, y); \
			if (any(greaterThanEqual(p, res)) || any(lessThan(p, ivec2(0)))) \
				continue; \
			out += imageLoad(tex, p).rgb * scale; \
		} /* for y */ \
	} /* for x */ \
}

#if 1
	const int DIRECT_DIFFUSE_KERNEL = 3;
	const int DIRECT_SPECULAR_KERNEL = 2;
	const int INDIRECT_DIFFUSE_KERNEL = 5;
	const int INDIRECT_SPECULAR_KERNEL = 2;
#else
	const int DIRECT_DIFFUSE_KERNEL = 1;
	const int DIRECT_SPECULAR_KERNEL = 1;
	const int INDIRECT_DIFFUSE_KERNEL = 1;
	const int INDIRECT_SPECULAR_KERNEL = 1;
#endif

Components boxBlurSamples(ivec2 res, ivec2 pix) {
	Components c;
	c.direct_diffuse = c.direct_specular = c.indirect_diffuse = c.indirect_specular = vec3(0.);

	BOX_BLUR(c.direct_diffuse, light_poly_diffuse, res, pix, DIRECT_DIFFUSE_KERNEL);
	BOX_BLUR(c.direct_diffuse, light_point_diffuse, res, pix, DIRECT_DIFFUSE_KERNEL);

	BOX_BLUR(c.direct_specular, light_poly_specular, res, pix, DIRECT_SPECULAR_KERNEL);
	BOX_BLUR(c.direct_specular, light_point_specular, res, pix, DIRECT_SPECULAR_KERNEL);

	res /= 2;
	pix /= 2;
	BOX_BLUR(c.indirect_diffuse, indirect_diffuse, res, pix, INDIRECT_DIFFUSE_KERNEL);
	BOX_BLUR(c.indirect_specular, indirect_specular, res, pix, INDIRECT_SPECULAR_KERNEL);

	return c;
}

Components blurATrous(const ivec2 res, const ivec2 pix, vec3 pos, vec3 shading_normal, vec3 geometry_normal) {
	Components c;
	c.direct_diffuse = c.direct_specular = c.indirect_diffuse = c.indirect_specular = vec3(0.);

	float weight_total_diffuse = 0.;
	float weight_total_specular = 0.;
	float weight_total_indirect_diffuse = 0.;
	float weight_total_indirect_specular = 0.;
	vec3 indirect_diffuse_c2 = vec3(0.);
	const ivec2 res_scaled = res / INDIRECT_SCALE;
	for (int x = 0; x <= ATROUS_KERNEL_WIDTH; ++x) {
		for (int y = 0; y <= ATROUS_KERNEL_WIDTH; ++y) {
			const ivec2 offset = ivec2(x, y);
			// 1. Direct diffuse
			{
				const float sn_phi = .5;
				const float p_phi = 2.;
				const int step_width = 3;
				ivec2 p;
				const float weight = aTrousSampleWeigth(
					res, pix, pos, shading_normal, offset, step_width, 1, sn_phi, p_phi, p);

				if (weight > 0.) {
					weight_total_diffuse += weight;
					c.direct_diffuse +=
						(imageLoad(light_poly_diffuse, p).rgb
						+imageLoad(light_point_diffuse, p).rgb) * weight;
				}
			}

			// 2. Direct specular
			{
				const float sn_phi = .5;
				const float p_phi = 1.;
				const int step_width = 1;
				ivec2 p;
				const float weight = aTrousSampleWeigth(
					res, pix, pos, shading_normal, offset, step_width, 1, sn_phi, p_phi, p);

				if (weight > 0.) {
					weight_total_specular += weight;
					c.direct_specular +=
						(imageLoad(light_poly_specular, p).rgb
						+imageLoad(light_point_specular, p).rgb) * weight;
				}
			}

			// 3. Indirect diffuse
			{
				const float sn_phi = .5;
				const float p_phi = 3.;
				const int step_width = 2;
				ivec2 p;
				const float weight = aTrousSampleWeigth(
					res, pix, pos, shading_normal, offset, step_width, 1, sn_phi, p_phi, p);

				if (weight > 0.) {
					const ivec2 p_scaled = p / INDIRECT_SCALE;
					const bool do_indirect = all(lessThan(p_scaled, res_scaled));
					if (do_indirect) {
						weight_total_indirect_diffuse += weight;
						indirect_diffuse_c2 += imageLoad(indirect_diffuse_atrous1, p_scaled).rgb * weight;
					}
				}
			}

			// 4. Indirect specular
			{
				const float sn_phi = .5;
				const float p_phi = 1.;
				const int step_width = 1;
				ivec2 p;
				const float weight = aTrousSampleWeigth(
					res, pix, pos, shading_normal, offset, step_width, 1, sn_phi, p_phi, p);

				if (weight > 0.) {
					const ivec2 p_scaled = p / INDIRECT_SCALE;
					const bool do_indirect = all(lessThan(p_scaled, res_scaled));
					if (do_indirect) {
						weight_total_indirect_specular += weight;
						c.indirect_specular += imageLoad(indirect_specular, p_scaled).rgb * weight;
					}
				}
			}
		} // for y
	} // for x

	const float one_over_weight_diffuse = 1. / weight_total_diffuse;
	const float one_over_weight_specular = 1. / weight_total_specular;
	const float one_over_weight_indirect_diffuse = 1. / weight_total_indirect_diffuse;
	const float one_over_weight_indirect_specular = 1. / weight_total_indirect_specular;
	c.direct_diffuse *= one_over_weight_diffuse;
	c.direct_specular *= one_over_weight_specular;

	indirect_diffuse_c2 *= one_over_weight_indirect_diffuse;
	c.indirect_specular *= one_over_weight_indirect_specular;

	const vec3 indirect_diffuse_c0 = imageLoad(indirect_diffuse, pix / INDIRECT_SCALE).rgb;
	const vec3 indirect_diffuse_c1 = imageLoad(indirect_diffuse_atrous1, pix / INDIRECT_SCALE).rgb;
	const vec3 d0 = indirect_diffuse_c1 - indirect_diffuse_c0;
	const vec3 d1 = indirect_diffuse_c2 - indirect_diffuse_c1;

	// TODO(or not todo): The Á-Trous paper mentions that it should be c2 + d1 + d0, but
	// it gives horrible artifacts. Either I'm misreading the paper, or something else is broken here,
	// Using just c2 seems fine enough (although still not up to original paper image quality)
	c.indirect_diffuse = indirect_diffuse_c2;// + d1 + d0;
	return c;
}

Components blurSamples(const ivec2 res, const ivec2 pix) {
	Components c;
	c.direct_diffuse = c.direct_specular = c.indirect_diffuse = c.indirect_specular = vec3(0.);

	const vec4 center_pos = imageLoad(position_t, pix);

	const int KERNEL_SIZE = max(max(max(DIRECT_DIFFUSE_KERNEL, INDIRECT_DIFFUSE_KERNEL), DIRECT_SPECULAR_KERNEL), INDIRECT_SPECULAR_KERNEL);

	const float direct_diffuse_sigma = DIRECT_DIFFUSE_KERNEL / 2.;
	const float indirect_diffuse_sigma = INDIRECT_DIFFUSE_KERNEL / 2.;
	const float direct_specular_sigma = DIRECT_SPECULAR_KERNEL / 2.;
	const float indirect_specular_sigma = INDIRECT_SPECULAR_KERNEL / 2.;

	float direct_diffuse_total = 0.;
	float indirect_diffuse_total = 0.;
	float direct_specular_total = 0.;
	float indirect_specular_total = 0.;

	const ivec2 res_scaled = res / INDIRECT_SCALE;
	for (int x = -KERNEL_SIZE; x <= KERNEL_SIZE; ++x)
		for (int y = -KERNEL_SIZE; y <= KERNEL_SIZE; ++y) {
			const ivec2 p = pix + ivec2(x, y);
			if (any(greaterThanEqual(p, res)) || any(lessThan(p, ivec2(0)))) {
				continue;
			}

			vec3 sample_geometry_normal, sample_shading_normal;
			readNormals(p, sample_geometry_normal, sample_shading_normal);

			float scale = 1.f;
			// FIXME also filter by depth, (kusok index?), etc
			//scale *= smoothstep(.9, 1., dot(sample_geometry_normal, geometry_normal));

			const vec4 sample_pos = imageLoad(position_t, p);
			// FIXME what are these magic numbers?
			scale *= smoothstep(center_pos.w * 4. / 100., 0., distance(center_pos.xyz, sample_pos.xyz));

			if ( scale <= 0. )
				continue;

			const ivec2 p_indirect = pix / INDIRECT_SCALE + ivec2(x, y);
			const bool do_indirect = all(lessThan(p_indirect, res_scaled)) && all(greaterThanEqual(p_indirect, ivec2(0)));

			if (all(lessThan(abs(ivec2(x, y)), ivec2(DIRECT_DIFFUSE_KERNEL))))
			{
				const float direct_diffuse_scale = scale * normpdf(x, direct_diffuse_sigma) * normpdf(y, direct_diffuse_sigma);
				direct_diffuse_total += direct_diffuse_scale;

				c.direct_diffuse += imageLoad(light_point_diffuse, p).rgb * direct_diffuse_scale;
				c.direct_diffuse += imageLoad(light_poly_diffuse, p).rgb * direct_diffuse_scale;
			}

			if (all(lessThan(abs(ivec2(x, y)), ivec2(INDIRECT_DIFFUSE_KERNEL))) && do_indirect)
			{
				// TODO indirect operates at different scale, do a separate pass
				const float indirect_diffuse_scale = scale
					* normpdf(x, indirect_diffuse_sigma)
					* normpdf(y, indirect_diffuse_sigma);

				indirect_diffuse_total += indirect_diffuse_scale;
				c.indirect_diffuse += imageLoad(indirect_diffuse, p_indirect).rgb * indirect_diffuse_scale;
			}

			if (all(lessThan(abs(ivec2(x, y)), ivec2(DIRECT_SPECULAR_KERNEL))))
			{
				const float specular_scale = scale * normpdf(x, direct_specular_sigma) * normpdf(y, direct_specular_sigma);
				direct_specular_total += specular_scale;

				c.direct_specular += imageLoad(light_poly_specular, p).rgb * specular_scale;
				DEBUG_VALIDATE_VEC3(c.direct_specular, "%d c.direct_specular=(%f,%f,%f) poly");

				c.direct_specular += imageLoad(light_point_specular, p).rgb * specular_scale;
				DEBUG_VALIDATE_VEC3(c.direct_specular, "%d c.direct_specular=(%f,%f,%f) point");
			}

			if (all(lessThan(abs(ivec2(x, y)), ivec2(INDIRECT_SPECULAR_KERNEL)))) {
				const ivec2 p_indirect = (pix + ivec2(x, y)) / INDIRECT_SCALE;// + ivec2(x, y);
				const bool do_indirect = all(lessThan(p_indirect, res_scaled)) && all(greaterThanEqual(p_indirect, ivec2(0)));

				if (do_indirect) {
					// TODO indirect operates at different scale, do a separate pass
					const float specular_scale = scale * normpdf(x, indirect_specular_sigma) * normpdf(y, indirect_specular_sigma);
					indirect_specular_total += specular_scale;
					c.indirect_specular += imageLoad(indirect_specular, p_indirect).rgb * specular_scale;
				}
			}
		}

	if (direct_diffuse_total > 0.)
		c.direct_diffuse /= direct_diffuse_total;

	if (indirect_diffuse_total > 0.)
		c.indirect_diffuse *= indirect_diffuse_total;

#ifdef DEBUG_VALIDATE_EXTRA
	if (IS_INVALIDV(c.direct_specular)) {
		debugPrintfEXT("c.direct_specular=(%f,%f,%f)", PRIVEC3(c.direct_specular));
		c.direct_specular = vec3(0.);
	}

	if (IS_INVALID(direct_specular_total)) {
		debugPrintfEXT("direct_specular_total=%f", direct_specular_total);
		direct_specular_total = 0.;
	}
#endif

	if (direct_specular_total > 0.)
		c.direct_specular *= direct_specular_total;

	if (indirect_specular_total > 0.)
		c.indirect_specular *= indirect_specular_total;

#ifdef DEBUG_VALIDATE_EXTRA
	if (IS_INVALIDV(c.indirect_specular)) {
		debugPrintfEXT("c.indirect_specular=(%f,%f,%f)", PRIVEC3(c.indirect_specular));
		c.indirect_specular = vec3(0.);
	}
#endif

	return c;
}

void main() {
	const ivec2 res = ubo.ubo.res;
	const ivec2 pix = ivec2(gl_GlobalInvocationID);

	if (any(greaterThanEqual(pix, res))) {
		return;
	}

	const vec3 position = imageLoad(position_t, pix).xyz;
	vec3 geometry_normal, shading_normal;
	readNormals(pix, geometry_normal, shading_normal);

	if (ubo.ubo.debug_display_only == DEBUG_DISPLAY_DISABLED) {
		// no-op, just continue
	} else if (ubo.ubo.debug_display_only == DEBUG_DISPLAY_BASECOLOR) {
		imageStore(out_dest, pix, vec4(LINEARtoSRGB(imageLoad(base_color_a, pix).rgb), 0.)); return;
		return;
	} else if (ubo.ubo.debug_display_only == DEBUG_DISPLAY_BASEALPHA) {
		imageStore(out_dest, pix, imageLoad(base_color_a, pix).aaaa); return;
		return;
	} else if (ubo.ubo.debug_display_only == DEBUG_DISPLAY_EMISSIVE) {
		imageStore(out_dest, pix, vec4(LINEARtoSRGB(imageLoad(emissive, pix).rgb), 0.)); return;
		return;
	} else if (ubo.ubo.debug_display_only == DEBUG_DISPLAY_MATERIAL) {
		imageStore(out_dest, pix, vec4(imageLoad(material_rmxx, pix).rg, 0., 0.)); return;
		return;
	} else if (ubo.ubo.debug_display_only == DEBUG_DISPLAY_NSHADE) {
		imageStore(out_dest, pix, vec4(.5 + shading_normal * .5, 0.));
		return;
	} else if (ubo.ubo.debug_display_only == DEBUG_DISPLAY_NGEOM) {
		imageStore(out_dest, pix, vec4(.5 + geometry_normal * .5, 0.));
		return;
	}

#ifdef DEBUG_NOISE
	imageStore(out_dest, pix, blueNoise(ivec3(pix.xy, ubo.ubo.frame_counter))); return;
#endif

	//const Components c = blurSamples(res, pix);
	//const Components c = boxBlurSamples(res, pix);
	//const Components c = dontBlurSamples(res, pix);
	const Components c = blurATrous(res, pix, position, shading_normal, geometry_normal);

	if (ubo.ubo.debug_display_only == DEBUG_DISPLAY_DISABLED) {
		// Skip
	} else if (ubo.ubo.debug_display_only == DEBUG_DISPLAY_DIRECT) {
		imageStore(out_dest, pix, vec4(LINEARtoSRGB(c.direct_diffuse + c.direct_specular), 0.)); return;
		return;
	} else if (ubo.ubo.debug_display_only == DEBUG_DISPLAY_DIRECT_DIFF) {
		imageStore(out_dest, pix, vec4(LINEARtoSRGB(c.direct_diffuse), 0.)); return;
		return;
	} else if (ubo.ubo.debug_display_only == DEBUG_DISPLAY_DIRECT_SPEC) {
		imageStore(out_dest, pix, vec4(LINEARtoSRGB(c.direct_specular), 0.)); return;
		return;
	} else if (ubo.ubo.debug_display_only == DEBUG_DISPLAY_INDIRECT) {
		imageStore(out_dest, pix, vec4(LINEARtoSRGB(c.indirect_diffuse + c.indirect_specular), 0.)); return;
		return;
	} else if (ubo.ubo.debug_display_only == DEBUG_DISPLAY_INDIRECT_SPEC) {
		imageStore(out_dest, pix, vec4(LINEARtoSRGB(c.indirect_specular), 0.)); return;
		return;
	} else if (ubo.ubo.debug_display_only == DEBUG_DISPLAY_INDIRECT_DIFF) {
		imageStore(out_dest, pix, vec4(LINEARtoSRGB(c.indirect_diffuse), 0.)); return;
		return;
	} else if (ubo.ubo.debug_display_only == DEBUG_DISPLAY_DIFFUSE) {
		imageStore(out_dest, pix, vec4(LINEARtoSRGB(c.indirect_diffuse + c.direct_diffuse), 0.)); return;
		return;
	} else if (ubo.ubo.debug_display_only == DEBUG_DISPLAY_SPECULAR) {
		imageStore(out_dest, pix, vec4(LINEARtoSRGB(c.indirect_specular + c.direct_specular), 0.)); return;
		return;
	}

	vec3 diffuse = c.direct_diffuse + c.indirect_diffuse;
	vec3 specular = c.direct_specular + c.indirect_specular;
	{
//#define DISABLE_TEMPORAL_DENOISER
#ifndef DISABLE_TEMPORAL_DENOISER
		// TODO: need to extract reprojecting from this shader because reprojected stuff need svgf denoising pass after it
		const vec3 origin = (ubo.ubo.inv_view * vec4(0., 0., 0., 1.)).xyz;
		const float depth = length(origin - position);
		const vec3 prev_position = imageLoad(geometry_prev_position, pix).rgb;
		const vec4 clip_space = inverse(ubo.ubo.prev_inv_proj) * vec4((inverse(ubo.ubo.prev_inv_view) * vec4(prev_position, 1.)).xyz, 1.);
		const vec2 reproj_uv = clip_space.xy / clip_space.w;
		const ivec2 reproj_pix = ivec2((reproj_uv * 0.5 + vec2(0.5)) * vec2(res));
		const vec3 prev_origin = (ubo.ubo.prev_inv_view * vec4(0., 0., 0., 1.)).xyz;
		const float depth_nessesary = length(prev_position - prev_origin);
		const float depth_treshold = 0.01 * clip_space.w;

		float better_depth_offset = depth_treshold;
		vec3 history_diffuse = diffuse;
		vec3 history_specular = specular;
		const int TEMPORAL_KERNEL = 1; // lifekilled says it should be fixed
		for(int x = -TEMPORAL_KERNEL; x <=TEMPORAL_KERNEL; x++) {
			for(int y = -TEMPORAL_KERNEL; y <=TEMPORAL_KERNEL; y++) {
				const ivec2 p = reproj_pix + ivec2(x, y);
				if (any(greaterThanEqual(p, res)) || any(lessThan(p, ivec2(0)))) {
					continue;
				}

				if (any(greaterThanEqual(reproj_pix, res)) || any(lessThan(reproj_pix, ivec2(0)))) {
					continue;
				}
				const vec4 history_diffuse_depth = imageLoad( prev_temporal_diffuse, reproj_pix );
				const vec4 history_specular_sample = imageLoad( prev_temporal_specular, reproj_pix );

				const float history_depth = history_diffuse_depth.w;
				const float depth_offset = abs(history_depth - depth_nessesary);
				if ( depth_offset < better_depth_offset ) {
					better_depth_offset = depth_offset;
					history_diffuse = history_diffuse_depth.rgb;
					history_specular = history_specular_sample.rgb;
				}
			}
		}

#ifdef DEBUG_VALIDATE_EXTRA
		if (IS_INVALIDV(history_specular)) {
			debugPrintfEXT("PRE pix=(%d,%d) history_specular=inv", pix.x, pix.y);
			history_specular = vec3(0.);
		}

		if (IS_INVALIDV(specular)) {
			debugPrintfEXT("PRE pix=(%d,%d) specular=(%f,%f,%f)", pix.x, pix.y, PRIVEC3(specular));
			specular = vec3(0.);
		}
#endif

		if (better_depth_offset < depth_treshold) {
			diffuse = mix(diffuse, history_diffuse, 0.8);
			specular = mix(specular, history_specular, 0.3);
		}

#ifdef DEBUG_VALIDATE_EXTRA
		if (IS_INVALIDV(diffuse)) {
			debugPrintfEXT("pix=(%d,%d) diffuse=inv", pix.x, pix.y);
			diffuse = vec3(0.);
		}

		if (IS_INVALIDV(specular)) {
			debugPrintfEXT("pix=(%d,%d) new_specular=inv, specular=(%f, %f, %f) history_specular=(%f, %f, %f)",
				pix.x, pix.y,
				specular.r, specular.g, specular.b,
				history_specular.r, history_specular.g, history_specular.b
				);
			specular = vec3(0.);
		}
#endif

		DEBUG_VALIDATE_RANGE_VEC3("denoiser.diffuse", diffuse, 0., 1e6);
		DEBUG_VALIDATE_RANGE_VEC3("denoiser.specular", specular, 0., 1e6);

		imageStore(out_temporal_diffuse, pix, vec4(diffuse, depth));
		imageStore(out_temporal_specular, pix, vec4(specular, 0./*unused*/));
#endif // ifndef DISABLE_TEMPORAL_DENOISER
	}

	vec3 colour = vec3(0.);

	if (ubo.ubo.debug_display_only != DEBUG_DISPLAY_LIGHTING) {
		const vec3 base_color = SRGBtoLINEAR(imageLoad(base_color_a, pix).rgb);
		const float metalness = imageLoad(material_rmxx, pix).g;
		colour = mixFinalColor(base_color, diffuse, specular, metalness);
	} else {
		colour = diffuse + specular;
	}

	const vec4 legacy_blend = imageLoad(legacy_blend, pix);

	colour += imageLoad(emissive, pix).rgb;
	// Revealage. TODO: which colorspace?
	colour *= legacy_blend.a;

	colour = LINEARtoSRGB(colour);

// See issue https://github.com/w23/xash3d-fwgs/issues/668, map test_blendmode_additive_alpha.
// Adding emissive_blend to the final color in the *incorrect* sRGB-γ space. It makes
// it look much more like the original. Adding emissive in the *correct* linear space differs
// from the original a lot, and looks perceptively worse.
	colour += legacy_blend.rgb;

	DEBUG_VALIDATE_RANGE_VEC3("denoiser.colour", colour, 0., 1e6);

	imageStore(out_dest, pix, vec4(colour, 0./*unused*/));
}