1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
// G-buffer channel visualization — 4×6 grid of 23 feature channels.
// Takes feat_tex0 (rgba32uint, ch 0-7 f16) and feat_tex1 (rgba32uint, ch 8-22 unorm8).
// Outputs tiled channel view to a standard rgba8unorm render target.
//
// Channel layout (row×col):
// Row 0: ch0(alb.r) ch1(alb.g) ch2(alb.b) ch3(nrm.x)
// Row 1: ch4(nrm.y) ch5(depth) ch6(dzdx) ch7(dzdy)
// Row 2: ch8(matid) ch9(prv.r) ch10(prv.g) ch11(prv.b)
// Row 3: ch12(m1.r) ch13(m1.g) ch14(m1.b) ch15(m2.r)
// Row 4: ch16(m2.g) ch17(m2.b) ch18(trns) ch19(spare)
// Row 5: ch20(dif.r) ch21(dif.g) ch22(dif.b) ch23(spare)
#include "debug/debug_print"
struct GBufViewUniforms { resolution: vec2f }
@group(0) @binding(0) var feat0: texture_2d<u32>;
@group(0) @binding(1) var feat1: texture_2d<u32>;
@group(0) @binding(2) var<uniform> u: GBufViewUniforms;
@vertex
fn vs_main(@builtin(vertex_index) vid: u32) -> @builtin(position) vec4f {
var corners = array<vec2f, 3>(
vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0));
return vec4f(corners[vid], 0.0, 1.0);
}
@fragment
fn fs_main(@builtin(position) pos: vec4f) -> @location(0) vec4f {
let uv = pos.xy / u.resolution;
let COLS = 4.0;
let ROWS = 6.0;
let col = u32(uv.x * COLS);
let row = u32(uv.y * ROWS);
let ch = row * 4u + col;
if (col >= 4u || ch == 19u || ch >= 23u) {
return vec4f(0.05, 0.05, 0.05, 1.0);
}
// 1-pixel grid lines (thin border per cell)
let lx = fract(uv.x * COLS);
let ly = fract(uv.y * ROWS);
if (lx < 0.005 || lx > 0.995 || ly < 0.005 || ly > 0.995) {
return vec4f(0.25, 0.25, 0.25, 1.0);
}
// Map local UV to texel coordinate
let dim = vec2i(textureDimensions(feat0));
let tc = clamp(vec2i(vec2f(lx, ly) * vec2f(dim)), vec2i(0), dim - vec2i(1));
var v: f32 = 0.0;
if (ch < 8u) {
// feat0: 4 × pack2x16float — each u32 component holds two f16 values
let t = textureLoad(feat0, tc, 0);
let pair_idx = ch >> 1u;
let sub = ch & 1u;
var p: vec2f;
if (pair_idx == 0u) { p = unpack2x16float(t.x); }
else if (pair_idx == 1u) { p = unpack2x16float(t.y); }
else if (pair_idx == 2u) { p = unpack2x16float(t.z); }
else { p = unpack2x16float(t.w); }
v = select(p.y, p.x, sub == 0u);
} else {
// feat1: 3 × pack4x8unorm — components .x/.y/.z hold 4 u8 values each
let t = textureLoad(feat1, tc, 0);
let ch1 = ch - 8u;
let comp_idx = ch1 / 4u;
let sub = ch1 % 4u;
var bytes: vec4f;
if (comp_idx == 0u) { bytes = unpack4x8unorm(t.x); }
else if (comp_idx == 1u) { bytes = unpack4x8unorm(t.y); }
else if (comp_idx == 2u) { bytes = unpack4x8unorm(t.z); }
else { bytes = unpack4x8unorm(t.w); }
var ba = array<f32, 4>(bytes.x, bytes.y, bytes.z, bytes.w);
v = ba[sub];
}
// Channel-specific normalization for display clarity
var disp: f32;
if (ch <= 2u) {
// Albedo: already [0,1]
disp = clamp(v, 0.0, 1.0);
} else if (ch == 3u || ch == 4u) {
// Normals oct-encoded in [-1,1] → remap to [0,1]
disp = clamp(v * 0.5 + 0.5, 0.0, 1.0);
} else if (ch == 5u) {
// Depth [0,1]: invert so near=white, far=dark
disp = clamp(1.0 - v, 0.0, 1.0);
} else if (ch == 6u || ch == 7u) {
// Depth gradients (signed, small values): amplify × 20 + 0.5 for visibility
disp = clamp(v * 20.0 + 0.5, 0.0, 1.0);
} else {
// Everything else: clamp to [0,1]
disp = clamp(v, 0.0, 1.0);
}
var out = vec4f(disp, disp, disp, 1.0);
// Label at top-left of each tile
let tile_w = u.resolution.x / 4.0;
let tile_h = u.resolution.y / 5.0;
let origin = vec2f(f32(col) * tile_w + 4.0, f32(row) * tile_h + 4.0);
switch ch {
case 0u: { out = debug_str(out, pos.xy, origin, vec4u(0x616C622Eu, 0x72000000u, 0u, 0u), 5u); } // alb.r
case 1u: { out = debug_str(out, pos.xy, origin, vec4u(0x616C622Eu, 0x67000000u, 0u, 0u), 5u); } // alb.g
case 2u: { out = debug_str(out, pos.xy, origin, vec4u(0x616C622Eu, 0x62000000u, 0u, 0u), 5u); } // alb.b
case 3u: { out = debug_str(out, pos.xy, origin, vec4u(0x6E726D2Eu, 0x78000000u, 0u, 0u), 5u); } // nrm.x
case 4u: { out = debug_str(out, pos.xy, origin, vec4u(0x6E726D2Eu, 0x79000000u, 0u, 0u), 5u); } // nrm.y
case 5u: { out = debug_str(out, pos.xy, origin, vec4u(0x64657074u, 0x68000000u, 0u, 0u), 5u); } // depth
case 6u: { out = debug_str(out, pos.xy, origin, vec4u(0x647A6478u, 0u, 0u, 0u), 4u); } // dzdx
case 7u: { out = debug_str(out, pos.xy, origin, vec4u(0x647A6479u, 0u, 0u, 0u), 4u); } // dzdy
case 8u: { out = debug_str(out, pos.xy, origin, vec4u(0x6D617469u, 0x64000000u, 0u, 0u), 5u); } // matid
case 9u: { out = debug_str(out, pos.xy, origin, vec4u(0x7072762Eu, 0x72000000u, 0u, 0u), 5u); } // prv.r
case 10u: { out = debug_str(out, pos.xy, origin, vec4u(0x7072762Eu, 0x67000000u, 0u, 0u), 5u); } // prv.g
case 11u: { out = debug_str(out, pos.xy, origin, vec4u(0x7072762Eu, 0x62000000u, 0u, 0u), 5u); } // prv.b
case 12u: { out = debug_str(out, pos.xy, origin, vec4u(0x6D312E72u, 0u, 0u, 0u), 4u); } // m1.r
case 13u: { out = debug_str(out, pos.xy, origin, vec4u(0x6D312E67u, 0u, 0u, 0u), 4u); } // m1.g
case 14u: { out = debug_str(out, pos.xy, origin, vec4u(0x6D312E62u, 0u, 0u, 0u), 4u); } // m1.b
case 15u: { out = debug_str(out, pos.xy, origin, vec4u(0x6D322E72u, 0u, 0u, 0u), 4u); } // m2.r
case 16u: { out = debug_str(out, pos.xy, origin, vec4u(0x6D322E67u, 0u, 0u, 0u), 4u); } // m2.g
case 17u: { out = debug_str(out, pos.xy, origin, vec4u(0x6D322E62u, 0u, 0u, 0u), 4u); } // m2.b
case 18u: { out = debug_str(out, pos.xy, origin, vec4u(0x74726E73u, 0u, 0u, 0u), 4u); } // trns
case 20u: { out = debug_str(out, pos.xy, origin, vec4u(0x6469662Eu, 0x72000000u, 0u, 0u), 5u); } // dif.r
case 21u: { out = debug_str(out, pos.xy, origin, vec4u(0x6469662Eu, 0x67000000u, 0u, 0u), 5u); } // dif.g
default: { out = debug_str(out, pos.xy, origin, vec4u(0x6469662Eu, 0x62000000u, 0u, 0u), 5u); } // dif.b
}
return out;
}
|
