23. A Shadow Query Is Still Bounded

A shadow is not a dark material painted behind an object. It is the result of asking whether the interval from a surface towards a light is clear. The compute shader already has every component of that question: a ray structure, primitive equations and a scene buffer. What changes is the interval and the required answer.

The primary query wants the closest surface over a long forward interval. The shadow query wants any blocker after a small starting offset but before the light. Once one valid blocker is found, searching for a closer one is unnecessary.

Ask the cheaper question

Write a Boolean scene query that exits on its first accepted candidate. It can call the same sphere equation and discard the returned position, normal and material. A specialised primitive predicate could later avoid that unused work, but using one trusted equation first prevents two subtly different intersection policies.

bool anySceneHit(Ray ray, float tMin, float tMax) {
    for (uint index = 0; index < control.sphereCount; ++index) {
        vec4 sphere = scene.spheres[index].centreRadius;
        Hit candidate = intersectSphere(
            ray, sphere.xyz, sphere.w, tMin, tMax);
        if (candidate.found) {
            return true;
        }
    }
    return false;
}

This result is independent of which blocker is encountered first because every valid blocker produces the same Boolean answer. Record order may affect the amount of work due to early exit, but not whether the light is blocked.

Build the interval from the light

vec3 toLight = uniforms.lightPosition.xyz - hit.position;
float lightDistance = length(toLight);
vec3 lightDirection = toLight / lightDistance;

const float shadowEpsilon = 0.001;
Ray shadowRay;
shadowRay.origin = hit.position + hit.normal * shadowEpsilon;
shadowRay.direction = lightDirection;

bool blocked = anySceneHit(
    shadowRay,
    shadowEpsilon,
    lightDistance - shadowEpsilon);

The maximum is not infinity. A sphere two units beyond the point light cannot prevent photons travelling from that light to the surface. The lower bound and shifted origin address numerical self-intersection close to the source surface. They are related safeguards, not permission to choose a huge arbitrary offset.

For a point light, subtracting the epsilon from the upper bound also avoids treating geometry exactly at or just beyond the light position as a blocker. If the resulting maximum is not greater than the minimum, the interval is empty and the query should be skipped.

Apply visibility to direct light only

vec3 shadeLocal(Hit hit, Ray ray) {
    MaterialGPU material = materials[hit.materialIndex];
    vec3 ambient = 0.025 * material.albedoRoughness.xyz;

    vec3 toLight = uniforms.lightPosition.xyz - hit.position;
    float lightDistance = length(toLight);
    vec3 L = toLight / lightDistance;

    Ray shadowRay = Ray(
        hit.position + hit.normal * control.shadowEpsilon,
        L);

    bool blocked = anySceneHit(
        shadowRay,
        control.shadowEpsilon,
        lightDistance - control.shadowEpsilon);

    if (blocked) {
        return ambient;
    }
    return ambient + directLight(material, hit, ray, L);
}

The ambient teaching approximation remains because it does not claim to arrive directly from this point light. Diffuse and specular terms are suppressed together when the point light is invisible. A later environment or indirect-light contribution would have its own visibility and sampling rules.

Do not hide the epsilon

Put the shadow epsilon in a named per-dispatch control rather than scattering a literal across functions. Test a deliberate range. If it is too small, round-off may cause the originating surface to shadow itself. If it is too large, a ray can leap over a nearby legitimate blocker or detach contact shadows.

A fixed world-space epsilon also changes meaning if the entire scene is rescaled. A renderer that must operate across different scene scales can account for hit distance, coordinate magnitude and floating-point error. The fixed value remains useful here because its failure can be observed directly and compared with the manual calculation from Lesson 8. State the scene scale and the chosen value whenever results are recorded.

Add counters as observers

Lesson 14 counted manual work. The compute tracer can do the same with a small storage buffer whose unsigned counters are updated atomically. Possible counters include primary primitive tests, shadow rays and shadow primitive tests. Atomics are necessary because many invocations update the same locations.

layout(std430, set = 0, binding = 4) buffer TraceCounters {
    uint primaryTests;
    uint shadowRays;
    uint shadowTests;
} counters;

// Before launching a shadow query:
atomicAdd(counters.shadowRays, 1u);

// Inside the shadow-loop body:
atomicAdd(counters.shadowTests, 1u);

Reset the counter buffer before the dispatch, make that reset visible to compute shader reads and writes, then make shader writes visible to the transfer or host readback used after completion. A convenient command sequence is fill buffer, barrier, trace dispatch, barrier, copy to a host-visible readback buffer. Wait for the submission's fence before reading the mapped result.

Counters perturb performance. Every pixel may contend on the same cache lines, so do not use an instrumented timing as the renderer's normal cost. They answer structural questions: how many tests were requested and how often early exit occurred.

Expect early exit to vary across invocations

Some shadow rays return on their first sphere; others inspect the whole array. Neighbouring shader invocations may therefore take different control paths. This divergence is a performance concern, not a reason to replace the bounded logic. The reference shader should first report the right visibility for every selected pixel.

Record reordering can reduce or increase the counter total because likely blockers appear earlier or later. It must not change the shadow mask. This distinction between answer and work becomes important when acceleration structures choose traversal order internally.

Official reference: the Khronos synchronization chapter defines availability and visibility, and the synchronization examples show common transfer and compute dependencies.

The scene now contains absence as a calculated result: direct light is present only when a bounded secondary query finds no obstruction. We have not invented a special shadow-drawing operation. We have reused the ray question with a different interval and a cheaper stopping condition.