ayo
34e6b0fe71
Add an experimental FSR Ray Regeneration backend for D3D12 RR requests: - Convert depth, motion, normals and albedos into AMD denoiser inputs. - Split and recompose diffuse/specular signals, then run Super Sampling. - Add stability/detail controls, demodulation guards and halo limiting. - Handle AMD provider discovery under NVIDIA GPU spoofing. - Add runtime probes, synthetic reference scenes and per-dispatch profiling. Add exact gfx11 DLSS-RR inference using f16 cooperative matrices: - Reproduce FP8 conversions, accumulation and camera reprojection arithmetic. - Widen model weights and avoid requiring VK_EXT_shader_float8. - Extend model building, replay tools and descriptor metadata. Expand motion preprocessing and experimental AW2 native-motion support: - Add tiled LDS dilation, padded allocation handling and thin-only sky fill. - Order dilation with input waits and NGX on the selected stream. - Add jitter-aligned native composition, hybrid routing and wire history repair. - Add prepared masks, sparse repair and independent motion/repair controls. Add optional fused R11G11B10 input/output conversion, sampled stage timings and profile summarization. Extend configuration, packaging, documentation, FidelityFX headers and CPU/GPU regression coverage.
56 lines
2.9 KiB
Plaintext
56 lines
2.9 KiB
Plaintext
#version 450
|
|
// FSR Ray Regeneration backend, stage 3: the denoised diffuse and specular signals remodulated by
|
|
// their albedos, plus the residual the denoiser never saw (particles, what demodulation could not
|
|
// carry, sky). The result is render-resolution colour for the Super Sampling stage.
|
|
layout(local_size_x = 8, local_size_y = 8) in;
|
|
|
|
layout(binding = 0, rgba16f) uniform readonly image2D denoisedDiffuse;
|
|
layout(binding = 1, rgba16f) uniform readonly image2D denoisedSpecular;
|
|
layout(binding = 2, rgba16f) uniform readonly image2D diffuseAlbedo;
|
|
layout(binding = 3, rgba16f) uniform readonly image2D specularAlbedo;
|
|
layout(binding = 4, rgba16f) uniform readonly image2D residual;
|
|
layout(binding = 5, rgba16f) uniform writeonly image2D composed;
|
|
layout(binding = 6, rgba16f) uniform readonly image2D noisyDiffuse;
|
|
layout(binding = 7, rgba16f) uniform readonly image2D noisySpecular;
|
|
|
|
layout(push_constant) uniform Constants
|
|
{
|
|
uvec2 renderSize;
|
|
float haloLimit; // > 0: each denoised lobe at most this multiple of the brightest noisy input of that lobe around it
|
|
uint unused;
|
|
} pc;
|
|
|
|
void main()
|
|
{
|
|
const ivec2 px = ivec2(gl_GlobalInvocationID.xy);
|
|
if (px.x >= int(pc.renderSize.x) || px.y >= int(pc.renderSize.y))
|
|
return;
|
|
const vec3 da = imageLoad(diffuseAlbedo, px).rgb, sa = imageLoad(specularAlbedo, px).rgb;
|
|
vec3 diffuse = imageLoad(denoisedDiffuse, px).rgb * da;
|
|
vec3 specular = imageLoad(denoisedSpecular, px).rgb * sa;
|
|
if (pc.haloLimit > 0.0)
|
|
{
|
|
// The denoiser can carry a thin object's large demodulated signal (dark albedo) across its edge, where this
|
|
// texel's albedo turns it into a bright fringe. A denoised value above everything around it in the noisy
|
|
// input is such a leak: capped, by luminance (the hue is kept).
|
|
const vec3 w = vec3(0.2126, 0.7152, 0.0722);
|
|
float diffuseMax = 0.0, specularMax = 0.0;
|
|
for (int dy = -1; dy <= 1; ++dy)
|
|
for (int dx = -1; dx <= 1; ++dx)
|
|
{
|
|
const ivec2 q = clamp(px + ivec2(dx, dy), ivec2(0), ivec2(pc.renderSize) - 1);
|
|
// what the lobe contributes there (the neighbour's own albedo): a leaked demodulated signal
|
|
// remodulated by this texel's albedo exceeds all of these
|
|
diffuseMax = max(diffuseMax, dot(imageLoad(noisyDiffuse, q).rgb * imageLoad(diffuseAlbedo, q).rgb, w));
|
|
specularMax = max(specularMax, dot(imageLoad(noisySpecular, q).rgb * imageLoad(specularAlbedo, q).rgb, w));
|
|
}
|
|
const float dl = dot(diffuse, w), sl = dot(specular, w);
|
|
if (dl > pc.haloLimit * diffuseMax)
|
|
diffuse *= pc.haloLimit * diffuseMax / dl;
|
|
if (sl > pc.haloLimit * specularMax)
|
|
specular *= pc.haloLimit * specularMax / sl;
|
|
}
|
|
const vec3 color = diffuse + specular + imageLoad(residual, px).rgb;
|
|
imageStore(composed, px, vec4(clamp(color, 0.0, 65000.0), 1.0));
|
|
}
|