376e66aeed
Restructure Sponza for the wavefront model: raygen emits the primary ray; closesthit (in SHADE) gathers albedo/normal, accumulates ambient, and emits a shadow ray carrying the pending direct term; miss adds the sky (primary) or the direct term (shadow miss). resolve.wgsl applies the same Reinhard+gamma the megakernel raygen did inline. User bindings moved to group 3 (groups 0..2 reserved). RTPass maxDepth=2. Renders the atrium correctly through the wavefront pipeline (textures, two-sided shading, sun+ambient, shadows, tonemap). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
89 lines
3.7 KiB
WebGPU Shading Language
89 lines
3.7 KiB
WebGPU Shading Language
// Sponza closest-hit (runs in SHADE). In the wavefront model the lighting
|
|
// + shadow trace that used to live in raygen happens here: gather surface
|
|
// data, accumulate ambient, and emit a shadow ray toward the sun carrying
|
|
// the pending direct contribution. The shadow ray's miss adds that
|
|
// contribution (sun visible); its hit adds nothing (occluded), since
|
|
// RT_FLAG_SKIP_CLOSEST_HIT suppresses closesthit on the shadow ray.
|
|
//
|
|
// Payload declared here so the assembler sees it before wfPayload / SHADE.
|
|
struct Payload {
|
|
color: vec3<f32>, // shadow ray: pending albedo·sun·nDotL
|
|
shadowRay: u32, // 0 primary, 1 shadow
|
|
};
|
|
|
|
// User resources at @group(3) (0..2 are the wavefront pipeline's reserved
|
|
// groups). binding 0 albedo array, 1 sampler, 2 camera (raygen only).
|
|
@group(3) @binding(0) var albedos : texture_2d_array<f32>;
|
|
@group(3) @binding(1) var samp : sampler;
|
|
|
|
const SUN_DIR_TO_LIGHT: vec3<f32> = vec3<f32>(-0.35, 1.00, -0.20);
|
|
const SUN_COLOR: vec3<f32> = vec3<f32>( 1.10, 1.00, 0.85);
|
|
const AMBIENT_COLOR: vec3<f32> = vec3<f32>( 0.18, 0.20, 0.28);
|
|
|
|
const ATTRIB_STRIDE_U32: u32 = 12u;
|
|
const ATTRIB_NORMAL_OFFSET: u32 = 0u;
|
|
const ATTRIB_UV_OFFSET: u32 = 8u;
|
|
|
|
fn fetchUV(meshRec: MeshRecord, vertexIdx: u32) -> vec2<f32> {
|
|
let base = meshRec.attribsOffset + vertexIdx * ATTRIB_STRIDE_U32 + ATTRIB_UV_OFFSET;
|
|
return vec2<f32>(
|
|
bitcast<f32>(vertexAttribs[base + 0u]),
|
|
bitcast<f32>(vertexAttribs[base + 1u]),
|
|
);
|
|
}
|
|
|
|
fn fetchNormal(meshRec: MeshRecord, vertexIdx: u32) -> vec3<f32> {
|
|
let base = meshRec.attribsOffset + vertexIdx * ATTRIB_STRIDE_U32 + ATTRIB_NORMAL_OFFSET;
|
|
return vec3<f32>(
|
|
bitcast<f32>(vertexAttribs[base + 0u]),
|
|
bitcast<f32>(vertexAttribs[base + 1u]),
|
|
bitcast<f32>(vertexAttribs[base + 2u]),
|
|
);
|
|
}
|
|
|
|
fn closesthit_main(ray: RayDesc, hit: HitInfo, payload: ptr<function, Payload>) {
|
|
let meshIdx = tlasEntries[hit.instanceId].blasMeshIdx;
|
|
let meshRec = meshRecords[meshIdx];
|
|
let baseIdx = meshRec.indexOffset + hit.primitiveId * 3u;
|
|
let i0 = indices[baseIdx + 0u];
|
|
let i1 = indices[baseIdx + 1u];
|
|
let i2 = indices[baseIdx + 2u];
|
|
let bary = vec3<f32>(1.0 - hit.attribs.x - hit.attribs.y, hit.attribs.x, hit.attribs.y);
|
|
|
|
let uv0 = fetchUV(meshRec, i0);
|
|
let uv1 = fetchUV(meshRec, i1);
|
|
let uv2 = fetchUV(meshRec, i2);
|
|
let uv = uv0 * bary.x + uv1 * bary.y + uv2 * bary.z;
|
|
let uvTiled = vec2<f32>(fract(uv.x), fract(1.0 - uv.y));
|
|
let layer = i32(hit.customIndex);
|
|
let albedo = textureSampleLevel(albedos, samp, uvTiled, layer, 0.0).rgb;
|
|
|
|
let n0 = fetchNormal(meshRec, i0);
|
|
let n1 = fetchNormal(meshRec, i1);
|
|
let n2 = fetchNormal(meshRec, i2);
|
|
let nObj = normalize(n0 * bary.x + n1 * bary.y + n2 * bary.z);
|
|
let nWorld = normalize(vec3<f32>(
|
|
dot(hit.objectToWorldR0.xyz, nObj),
|
|
dot(hit.objectToWorldR1.xyz, nObj),
|
|
dot(hit.objectToWorldR2.xyz, nObj)));
|
|
|
|
// Two-sided: flip the normal toward the camera (Sponza curtains have
|
|
// inconsistent winding).
|
|
let nFacing = select(-nWorld, nWorld, dot(nWorld, ray.direction) < 0.0);
|
|
let lightDir = normalize(SUN_DIR_TO_LIGHT);
|
|
let nDotL = max(0.0, dot(nFacing, lightDir));
|
|
let worldPos = ray.origin + ray.direction * hit.t;
|
|
|
|
// Ambient is unconditional; direct light is gated behind the shadow ray.
|
|
rtAccumulate(albedo * AMBIENT_COLOR);
|
|
|
|
if (nDotL > 0.0) {
|
|
let shadowOrigin = worldPos + nFacing * 0.5;
|
|
var sp: Payload;
|
|
sp.color = albedo * SUN_COLOR * nDotL;
|
|
sp.shadowRay = 1u;
|
|
rtEmitRay(shadowOrigin, 0.001, lightDir, 10000.0,
|
|
RT_FLAG_SKIP_CLOSEST_HIT | RT_FLAG_TERMINATE_ON_FIRST_HIT,
|
|
0xFFu, 0u, 0u, sp);
|
|
}
|
|
}
|