1import bevy_pbr::render::mesh_view_bindings::view;
2import bevy_pbr::render::mesh_view_bindings::depth_prepass_texture;
3import bevy_pbr::render::mesh_view_bindings::normal_prepass_texture;
4import bevy_pbr::render::mesh_view_bindings::motion_vector_prepass_texture;
5import bevy_pbr::render::mesh_view_bindings::deferred_prepass_texture;
6import bevy_pbr::render::view_transformations::depth_ndc_to_view_z;
7import bevy_pbr::deferred::types::unpack_24bit_normal;
8import bevy_pbr::deferred::types::unpack_unorm4x8_;
9import bevy_pbr::deferred::types::unpack_unorm3x4_plus_unorm_20_;
10import bevy_pbr::render::rgb9e5::rgb9e5_to_vec3_;
11import bevy_render::utils::octahedral_decode;
12
13struct DebugBufferConfig {
14    opacity: f32,
15    mip_level: u32,
16}
17
18@group(1) @binding(0) var<uniform> config: DebugBufferConfig;
19@group(1) @binding(1) var background_texture: texture_2d<f32>;
20@group(1) @binding(2) var background_sampler: sampler;
21
22@if(DEBUG_DEPTH_PYRAMID) {
23@group(1) @binding(3) var depth_pyramid_texture: texture_2d<f32>;
24@group(1) @binding(4) var depth_pyramid_sampler: sampler;
25}
26
27@fragment
28fn fragment(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
29    let uv = frag_coord.xy / view.viewport.zw;
30    let background = textureSampleLevel(background_texture, background_sampler, uv, 0.0);
31    var output_color: vec4<f32> = vec4(0.0);
32
33@if(DEBUG_DEPTH) {
34    @if(DEPTH_PREPASS) {
35        let depth = textureLoad(depth_prepass_texture, vec2<i32>(frag_coord.xy), 0);
36        output_color = vec4(vec3(depth), 1.0);
37    }
38    @else {
39        output_color = vec4(1.0, 0.0, 1.0, 1.0);
40    }
41}
42
43@if(DEBUG_NORMAL) {
44    @if(NORMAL_PREPASS) {
45        let normal_sample = textureLoad(normal_prepass_texture, vec2<i32>(frag_coord.xy), 0);
46        output_color = vec4(normal_sample.xyz, 1.0);
47    }
48    @else {
49        @if(DEFERRED_PREPASS) {
50            let deferred = textureLoad(deferred_prepass_texture, vec2<i32>(frag_coord.xy), 0);
51            let normal = octahedral_decode(unpack_24bit_normal(deferred.a));
52            output_color = vec4(normal * 0.5 + 0.5, 1.0);
53        }
54        @else {
55            output_color = vec4(1.0, 0.0, 1.0, 1.0);
56        }
57    }
58}
59
60@if(DEBUG_MOTION_VECTORS) {
61    @if(MOTION_VECTOR_PREPASS) {
62        let motion_vector = textureLoad(motion_vector_prepass_texture, vec2<i32>(frag_coord.xy), 0).rg;
63        // These motion vectors are stored in a format where 1.0 represents full-screen movement.
64        // We use a power curve to amplify small movements while keeping them centered.
65        let mapped_motion = sign(motion_vector) * pow(abs(motion_vector), vec2(0.2)) * 0.5 + 0.5;
66        output_color = vec4(mapped_motion, 0.5, 1.0);
67    }
68    @else {
69        output_color = vec4(1.0, 0.0, 1.0, 1.0);
70    }
71}
72
73@if(DEBUG_DEFERRED) {
74    @if(DEFERRED_PREPASS) {
75        let deferred = textureLoad(deferred_prepass_texture, vec2<i32>(frag_coord.xy), 0);
76        output_color = vec4(vec3(f32(deferred.x) / 255.0, f32(deferred.y) / 255.0, f32(deferred.z) / 255.0), 1.0);
77    }
78    @else {
79        output_color = vec4(1.0, 0.0, 1.0, 1.0);
80    }
81}
82
83@if(DEBUG_DEFERRED_BASE_COLOR) {
84    @if(DEFERRED_PREPASS) {
85        let deferred = textureLoad(deferred_prepass_texture, vec2<i32>(frag_coord.xy), 0);
86        let base_rough = unpack_unorm4x8_(deferred.x);
87        output_color = vec4(pow(base_rough.rgb, vec3(2.2)), 1.0);
88    }
89    @else {
90        output_color = vec4(1.0, 0.0, 1.0, 1.0);
91    }
92}
93
94@if(DEBUG_DEFERRED_EMISSIVE) {
95    @if(DEFERRED_PREPASS) {
96        let deferred = textureLoad(deferred_prepass_texture, vec2<i32>(frag_coord.xy), 0);
97        let emissive = rgb9e5_to_vec3_(deferred.y);
98        output_color = vec4(emissive, 1.0);
99    }
100    @else {
101        output_color = vec4(1.0, 0.0, 1.0, 1.0);
102    }
103}
104
105@if(DEBUG_DEFERRED_METALLIC_ROUGHNESS) {
106    @if(DEFERRED_PREPASS) {
107        let deferred = textureLoad(deferred_prepass_texture, vec2<i32>(frag_coord.xy), 0);
108        let base_rough = unpack_unorm4x8_(deferred.x);
109        let props = unpack_unorm4x8_(deferred.z);
110        // R: Reflectance, G: Metallic, B: Occlusion, A: Perceptual Roughness
111        output_color = vec4(props.r, props.g, props.b, base_rough.a);
112    }
113    @else {
114        output_color = vec4(1.0, 0.0, 1.0, 1.0);
115    }
116}
117
118@if(DEBUG_DEPTH_PYRAMID) {
119    let depth_pyramid = textureSampleLevel(depth_pyramid_texture, depth_pyramid_sampler, uv, f32(config.mip_level)).r;
120    output_color = vec4(vec3(depth_pyramid), 1.0);
121}
122
123    let alpha = output_color.a * config.opacity;
124    return vec4(mix(background.rgb, output_color.rgb, alpha), 1.0);
125}