22. Materials and Light Remain Separate

A visible surface is not yet a lit surface. The closest-hit query tells us where the ray arrived, which way the geometry faces and which primitive supplied the answer. Lighting requires different information: the surface's material, the light's position and intensity, and the view direction. Keeping those responsibilities separate is more than tidiness. It lets the same geometry answer primary, shadow and secondary queries without accidentally performing the wrong shading work.

The material table and light must therefore become shader-visible data. The local diffuse and specular model remains the one established in Lesson 7: calculate it in linear colour and encode the result only when writing the display image.

Make geometry identify a material

Extend the sphere record to two 16-byte units. The first remains centre and radius. The second carries a material index in its first component and leaves three explicit spare fields. Using an unsigned vector avoids asking GLSL to reinterpret a floating-point bit pattern.

struct alignas(16) SphereGPU {
    std::array<float, 4> centreRadius;
    std::array<std::uint32_t, 4> metadata;
};

static_assert(sizeof(SphereGPU) == 32);

struct alignas(16) MaterialGPU {
    std::array<float, 4> albedoRoughness;
    std::array<float, 4> specularPadding;
};

static_assert(sizeof(MaterialGPU) == 32);

For the local model, albedoRoughness.xyz stores diffuse reflectance, its w component may retain a future roughness value, and specularPadding.x stores specular strength. We will supply the exponent separately while investigating it. Explicit names on the CPU are preferable in production; the arrays here make the byte layout plain.

struct SphereGPU {
    vec4 centreRadius;
    uvec4 metadata;
};

struct MaterialGPU {
    vec4 albedoRoughness;
    vec4 specularPadding;
};

layout(std430, set = 0, binding = 3) readonly buffer MaterialBuffer {
    MaterialGPU materials[];
};

Add binding 3 to the descriptor set layout and upload the material table by the same staged method used for spheres. Validate every material index on the CPU before upload. Bounds checking in shader code can provide a conspicuous error material during development, but it should not be the first time the application notices an invalid scene.

Let the hit record carry identity

The private Hit gains a material index. intersectSphere remains concerned with geometry; the scene loop assigns the index only when it retains that sphere.

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

// Inside closestSceneHit, after candidate.found:
candidate.materialIndex = scene.spheres[index].metadata.x;
closest = candidate;
closestDistance = candidate.t;

Do not copy the full material into every candidate hit. A stable index is sufficient and keeps geometry records compact. The material is fetched once after the closest answer has been chosen.

Place one light in uniform data

Extend the camera uniform buffer with two aligned vectors: light position and an RGB intensity with a spare component. In a larger engine, camera and lighting data may have different update frequencies and therefore different buffers. One buffer is acceptable here because the objective is the relationship, not an allocation policy.

struct alignas(16) SceneUniforms {
    float cameraToWorld[16];
    float projection[4];
    float lightPosition[4];
    float lightIntensity[4];
    float cameraPosition[4];
};

Check the offsets used by the host structure against the GLSL block. A matrix layout, three-component member or compiler packing assumption can shift all later values while leaving the descriptor itself valid. During development, write the shader-observed light position into a debug pixel or buffer rather than diagnosing it from a strangely lit sphere.

Reconstruct the four directions

At the accepted position, form the unit normal N, unit direction L towards the light and unit direction V towards the camera. The incoming primary ray points from the camera to the surface, so V = normalize(-ray.direction). The reflection direction for a Phong-style specular term is obtained by reflecting -L around N.

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

    vec3 toLight = uniforms.lightPosition.xyz - hit.position;
    float lightDistance = length(toLight);
    vec3 L = toLight / lightDistance;
    vec3 N = normalize(hit.normal);
    vec3 V = normalize(-ray.direction);

    float nDotL = max(dot(N, L), 0.0);
    vec3 diffuse = albedo * nDotL;

    vec3 reflectedLight = reflect(-L, N);
    float specularAngle = max(dot(V, reflectedLight), 0.0);
    float exponent = control.specularExponent;
    float specular = material.specularPadding.x *
                     pow(specularAngle, exponent);

    vec3 incident = uniforms.lightIntensity.xyz;
    vec3 ambient = 0.025 * albedo;
    return ambient + incident * (diffuse + vec3(specular));
}

This deliberately simple light has no inverse-square attenuation yet. Add attenuation only when its units and intensity are explained; otherwise the apparent improvement is merely a new arbitrary scale. The ambient term is likewise an explicit teaching approximation, not light transport from the environment.

Keep the normal on the correct side

A primary ray can strike the inside of geometry after the camera moves or once secondary rays exist. Record whether the ray meets the outward-facing side:

bool frontFace = dot(ray.direction, outwardNormal) < 0.0;
hit.normal = frontFace ? outwardNormal : -outwardNormal;

The normal then opposes the arriving ray. Store frontFace if later material behaviour needs to know which medium was entered. Merely flipping the normal without retaining that fact is insufficient for refraction.

Encode only after lighting

The arithmetic above operates in linear colour. If the output image is an 8-bit UNORM format and the presentation path does not perform an sRGB conversion, apply an explicit linear-to-display approximation after clamping negative values. A simple teaching version uses a power of one over 2.2:

vec3 linearColour = hit.found
    ? shadeLocal(hit, ray)
    : vec3(0.015, 0.025, 0.022);

vec3 displayColour = pow(max(linearColour, vec3(0.0)),
                         vec3(1.0 / 2.2));
imageStore(outputImage, pixel, vec4(displayColour, 1.0));

Do not apply the power twice. If the storage image is copied into an sRGB-capable presentation path whose conversion you rely upon, document where encoding occurs and remove the shader conversion. The rule is one intentional encoding boundary.

Use diagnostic modes before admiring the picture

Retain selectable output modes for primitive index, material index, normal, diffuse factor and specular factor. A beautiful combined image can conceal a material-buffer offset error because several mistakes produce plausible colours. A material-index view should contain flat, exact regions matching the retained primitive. A diffuse-factor view should vary with only N dot L. A specular-factor view should react strongly when the recorded exponent is changed.

When the combined result disagrees with the manual scene, compare these intermediate quantities at one selected pixel. The GPU has not made the lighting model mysterious; it has made many evaluations simultaneous.

Official reference: the Khronos shader-interface chapter defines resource-interface matching, and the data mapping guide gives host and shader layout examples.

We now have the same local relationships as the manual tracer, expressed through Vulkan buffers and shader invocations. Geometry chooses the hit, a material describes the surface, and the light supplies incident direction and intensity. The remaining flaw is obvious: every accepted point receives the light even when another primitive stands between them.