Can meshes be reused in raytracing?

Question

In rasterization, at least in the context of game development, it is a common to have many instances of the same 3D object in a scene (think many identical rocks in different sizes/positions/rotations) and to render them by only putting the 3D object in GPU memory once and just updating the model matrix every time. This works relatively easily in rasterization since the rendering is done "object by object", but it allows to be way more efficient than if we were to upload several copies of the same mesh.

I was wondering: is that possible/usually done in raytracing? I was looking at the code from Raytracing in one Weekend and the author allocates one new sphere every time he adds a sphere to the scene:

for (int a = -11; a < 11; a++) {
    for (int b = -11; b < 11; b++) {
        auto choose_mat = random_double();
        point3 center(a + 0.9*random_double(), 0.2, b + 0.9*random_double());

        if ((center - point3(4, 0.2, 0)).length() > 0.9) {
            shared_ptr<material> sphere_material;

            if (choose_mat < 0.8) {
                // diffuse
                auto albedo = color::random() * color::random();
                sphere_material = make_shared<lambertian>(albedo);
                world.add(make_shared<sphere>(center, 0.2, sphere_material));
            } else if (choose_mat < 0.95) {
                // metal
                auto albedo = color::random(0.5, 1);
                auto fuzz = random_double(0, 0.5);
                sphere_material = make_shared<metal>(albedo, fuzz);
                world.add(make_shared<sphere>(center, 0.2, sphere_material));
            } else {
                // glass
                sphere_material = make_shared<dielectric>(1.5);
                world.add(make_shared<sphere>(center, 0.2, sphere_material));
            }
        }
    }
}

I wonder: is this done just for simplicity (after all it is a beginners raytracing course) or is it not an usual practice to reuse geometry in such renderers (possibly because the algorithms do not make it possible, as they evaluate the whole scene ar once)?

Answer 1

Example code tends to be bad code from a performance (or even software engineering) standpoint because... it's an example. Its primary purpose is to make it clear how to do a thing, not to do it in an efficient or well-structured way.

Ray tracing can reference "meshes" or any object definition just fine. You have the data for some mesh or whatever with its own model space, and you have zero or more instances of those objects in the world. Those instances each come with per-instance data, like their transformation into world space, any bounding volumes used for quick ray intersection tests, and attachments to whatever your spatial subdivision scheme is to make ray tracing fast.

In ray tracing, when testing ray intersection with an object in the world, you often transform the ray from world-space into the model space of that object. You then do intersection tests in the space of the mesh. That way, you're not transforming thousands of vertices or whatever for each ray intersection test. Once you get the intersection point+normal, you can transform those back into world-space to do world-space computations.

This also allows you to have a single "mesh" for basic objects like spheres and cubes. Scales in the model transform can be used to stretch spheres and cubes, thus allowing you to create a sphere/cube of any size. Also any rectangular parallelopiped. Or really, any parallelogram.