20. Move the Sphere Equation into Compute

A compute shader can evaluate thousands of sphere equations together, but parallelism does not alter the equation. Each invocation constructs one primary ray, substitutes it into the sphere's implicit surface and accepts the smallest root inside the requested interval. If the result differs from Lesson 4, “the GPU did it differently” is not an explanation. Either the data, arithmetic, interval or output has changed.

Begin with one sphere supplied through push constants. The scene buffer belongs to Lesson 21. Keeping only one primitive makes the first disagreement narrow: camera ray, sphere values, quadratic terms, roots or interval. The shader writes a normal diagnostic for a hit and a dark background for a miss, so Canvas-like shape drawing remains absent.

Add one small command-supplied record

The diagnostic sphere needs four floats. Its centre occupies xyz and its radius occupies w. The pipeline layout now includes a compute-stage push-constant range as well as the descriptor set layout. Recreate the pipeline after changing its layout; an existing pipeline does not acquire a new interface because the host structure changed.

struct alignas(16) TracePush {
    float centreX;
    float centreY;
    float centreZ;
    float radius;
};

VkPushConstantRange traceRange{
    .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
    .offset = 0,
    .size = sizeof(TracePush)
};

VkPipelineLayoutCreateInfo layoutInfo{
    .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
    .setLayoutCount = 1,
    .pSetLayouts = &setLayout,
    .pushConstantRangeCount = 1,
    .pPushConstantRanges = &traceRange
};

Query VkPhysicalDeviceLimits::maxPushConstantsSize and establish that the 16-byte range fits. Immediately before the dispatch, record the value using the same pipeline layout and stage range:

TracePush tracePush{ 0.0f, 0.0f, -3.0f, 1.0f };

vkCmdPushConstants(
    commandBuffer,
    pipelineLayout,
    VK_SHADER_STAGE_COMPUTE_BIT,
    0,
    sizeof(tracePush),
    &tracePush);

vkCmdDispatch(commandBuffer, groupsX, groupsY, 1);

The command copies the supplied bytes into command-buffer state for the named range. The pointer need not remain alive after recording. The layout and shader interpretation must still agree.

Return a deliberate hit record

Use a small result structure rather than returning only a Boolean. The accepted distance is needed to reconstruct position and normal. The first version has no material or face orientation because those responsibilities are not required to prove one sphere intersection.

layout(push_constant) uniform TracePush {
    vec4 centreRadius;
} tracePush;

struct Hit {
    bool found;
    float t;
    vec3 position;
    vec3 normal;
};

Hit noHit() {
    Hit hit;
    hit.found = false;
    hit.t = 0.0;
    hit.position = vec3(0.0);
    hit.normal = vec3(0.0);
    return hit;
}

Initialising every field avoids treating unspecified values from a miss as useful geometry. A shader compiler may optimise unused assignments, but the source contract remains readable.

Move the known equation, not an approximation of it

Hit intersectSphere(
    Ray ray,
    vec3 centre,
    float radius,
    float tMin,
    float tMax)
{
    vec3 offset = ray.origin - centre;
    float a = dot(ray.direction, ray.direction);
    float halfB = dot(offset, ray.direction);
    float c = dot(offset, offset) - radius * radius;
    float discriminant = halfB * halfB - a * c;

    if (discriminant < 0.0) {
        return noHit();
    }

    float rootScale = sqrt(discriminant);
    float root = (-halfB - rootScale) / a;

    if (root < tMin || root > tMax) {
        root = (-halfB + rootScale) / a;
        if (root < tMin || root > tMax) {
            return noHit();
        }
    }

    Hit hit;
    hit.found = true;
    hit.t = root;
    hit.position = ray.origin + root * ray.direction;
    hit.normal = normalize((hit.position - centre) / radius);
    return hit;
}

Ray directions are normalised, so a should be close to one. Retaining it in the equation makes the function honest about its input and provides a diagnostic if a later direction loses unit length. The accepted interval begins at a small positive value and ends at a large finite maximum for the primary query. A root behind the camera or below the minimum is not made visible by being mathematically real.

Write a diagnostic that exposes the hit

Ray ray = makePrimaryRay(gl_GlobalInvocationID.xy);
Hit hit = intersectSphere(
    ray,
    tracePush.centreRadius.xyz,
    tracePush.centreRadius.w,
    0.001,
    1000000.0);

vec3 colour = hit.found
    ? 0.5 * (hit.normal + vec3(1.0))
    : vec3(0.015, 0.025, 0.022);

imageStore(outputImage, ivec2(gl_GlobalInvocationID.xy),
           vec4(colour, 1.0));

The normal diagnostic distinguishes a geometric surface from a flat coloured disc. Its components should vary continuously across the visible sphere and its centre-facing normal should map near blue for the camera arrangement used here. Do not apply display gamma to this diagnostic comparison; the encoded normal is not a linear radiance value. Later lighting will separate linear calculation from display encoding.

Expect control-flow differences, not semantic differences

Invocations near the sphere execute the root and hit-record path; invocations outside return after the negative discriminant. The device may execute neighbouring invocations together, so this divergent control flow can affect performance. It does not permit a miss to borrow a hit from its neighbour. Optimisation begins after the per-invocation result agrees with the reference.

Replacing the branch with clever arithmetic may or may not improve a target implementation. It certainly increases the burden of showing that NaNs, tangent hits and rejected intervals remain correct. Keep the explicit version until measurement identifies it as a material cost.

Read back a small witness

A complete debug readback path requires a destination buffer with transfer-destination use, compatible host-visible memory, an image-to-buffer copy or dedicated shader debug buffer, and barriers stating the relevant writes and reads. Do not map device-local image memory merely because it was allocated. For this lesson, a small storage debug buffer containing one selected invocation's a, halfB, c, discriminant and accepted root is clearer than reading the whole image.

Guard the debug write with an exact selected pixel and give it one record, so no atomic operation is required. After dispatch, make the shader write visible to a transfer or host read path as appropriate, wait for completion and compare the values. Remove the diagnostic from performance measurements.

Official reference: the shader execution and interface rules remain defined by the Khronos shader chapter and shader-interface chapter.

We now have a sphere that exists because independent shader invocations solved its equation, not because a graphics pipeline rasterised a circle. The result is still deliberately limited: one object cannot expose traversal order, record layout or the closest-hit contract. Lesson 21 adds a scene buffer and ensures that buffer order does not become visibility order.