A renderer is a loop over pixels

Strip away the engine, the shaders and the GPU and a renderer is one question asked many times: for this pixel, which direction did light come from, and what did it hit? Answer it for every pixel and you have an image.

Two broad families answer it. In a simple teaching model, the choice between them is the first real decision:

Ray tracing — in a basic version, start at the camera and shoot one ray through each pixel to find the nearest hit; additional rays handle effects such as shadows and indirect light.

Rasterization — start at the triangles, project them onto the image, and generate fragments for the samples they cover.

Ray tracing makes visibility along a ray explicit, so shadow tests and specular reflection or transmission fit naturally into the same framework; each effect may still need extra rays and material models. Rasterization is designed to process many projected primitives efficiently. Modern engines combine both approaches, and neither makes the other obsolete.

// The whole of a first ray tracer, in pseudocode
for y in 0..height:
  for x in 0..width:
    ray   = camera.rayThrough(x, y)     // origin + direction
    hit   = scene.nearestHit(ray)       // brute force is fine at first
    color = hit ? shade(hit, ray) : background
    image[y][x] = color

// shade() is where all the physics lives:
//   normal, material, light directions, and later: recursion for reflection

The camera part is worth doing by hand once. A ray through pixel (x, y) is:

// Map pixel -> normalised device coords in [-1, 1]; fov is vertical here
ndc_x = (2*(x + 0.5) / width  - 1) * aspect * tan(fov/2)
ndc_y = (1 - 2*(y + 0.5) / height)         * tan(fov/2)

// Direction in camera space, then rotate into world space
dir_camera = normalize(vec3(ndc_x, ndc_y, -1))
dir_world  = cameraBasis * dir_camera

// The +0.5 matters: it samples the CENTRE of the pixel, not its corner.

Once this loop works you have the skeleton that everything else hangs on. Shadows are "shoot a ray at the light". Reflections are "call shade() again along the reflected direction". Depth of field is "jitter the ray origin over a lens". Same loop, richer question.