//////////////////////////////////////////////////////////////////////
// Provides the framework for a raytracer.
////////////////////////////////////////////////////////////////////////

#include "raytrace.h"

#define STB_IMAGE_IMPLEMENTATION
#define STBI_FAILURE_USERMSG
#include "stb_image.h"

// A good quality *thread-safe* Mersenne Twister random number generator.
#include <random>
std::random_device device;
std::mt19937_64 RNGen(device());
std::uniform_real_distribution<> myrandom(0.0, 1.0);
// Call myrandom(RNGen) to get a uniformly distributed random number in [0,1].

void Scene::Finit()
{
	this->accelStruc = new AccelerationBvh(this->shapes);
}

void Scene::triangleMesh(MeshData* mesh) 
{ 
    // Use the currentMat from the scene file (set by brdf command)
    // This allows the scene file to control mesh appearance
    Material* meshMat = currentMat;
    
    // Convert mesh data into individual Triangle shapes and add to scene
    for (const auto& tri : mesh->triangles) {
        // tri is an ivec3 containing three vertex indices
        vec3 v0 = mesh->vertices[tri[0]].pnt;
        vec3 v1 = mesh->vertices[tri[1]].pnt;
        vec3 v2 = mesh->vertices[tri[2]].pnt;
        
        // Create a Triangle shape and add it to the scene with the scene file's material
        this->shapes.push_back(new Triangle(v0, v1, v2, meshMat));
    }
}

Texture::Texture(const std::string &bpath) : id(0)
{
    // Replace backslashes with forward slashes -- Good for Linux, and maybe Windows?
    std::string path=bpath;
    std::string bs="\\";
    std::string fs="/";
    while (path.find(bs) != std::string::npos) {
        path.replace(path.find(bs), 1, fs);}
    
    // Does the file exist?
    std::ifstream find_it(path.c_str());
    if (find_it.fail()) {
        std::cerr << "Texture file not found: "  << path << std::endl;
        exit(-1); }
    else {
        // Read image, and check for success
        stbi_set_flip_vertically_on_load(true);
        image = stbi_load(path.c_str(), &width, &height, &depth, 4);
        printf("%d %d %d %s\n", depth, width, height, path.c_str());
        if (!image) {
            printf("\nRead error on file %s:\n  %s\n\n", path.c_str(), stbi_failure_reason());
            exit(-1); } }
}

quat Orientation(int i, 
                        const std::vector<std::string>& strings,
                        const std::vector<float>& f)
{
    quat q(1,0,0,0); // Unit quaternion
    while (i<strings.size()) {
        std::string c = strings[i++];
        if (c == "x")  
            q *= angleAxis(f[i++]*Radians, Xaxis());
        else if (c == "y")  
            q *= angleAxis(f[i++]*Radians, Yaxis());
        else if (c == "z")  
            q *= angleAxis(f[i++]*Radians, Zaxis());
        else if (c == "q")  {
            q *= quat(f[i+0], f[i+1], f[i+2], f[i+3]);
            i+=4; }
        else if (c == "a")  {
            q *= angleAxis(f[i+0]*Radians, normalize(vec3(f[i+1], f[i+2], f[i+3])));
            i+=4; } }
    return q;
}

void Scene::Command(const std::vector<std::string>& strings,
                    const std::vector<float>& f)
{
    if (strings.size() == 0) return;
    std::string c = strings[0];
    
    if (c == "screen") {
        // syntax: screen width height        
        width = int(f[1]);
        height = int(f[2]); 
    }

    else if (c == "camera") {
        // syntax: camera x y z   ry   <orientation spec>
        // Eye position (x,y,z),  view orientation (qw qx qy qz),  frustum height ratio ry        
		this->camera = new Camera(vec3(f[1], f[2], f[3]), Orientation(5, strings, f), f[4]);
    }


    else if (c == "ambient") {
        // syntax: ambient r g b
        // Sets the ambient color.  Note: This parameter is temporary.
        // It will be ignored once your raytracer becomes capable of
        // accurately *calculating* the true ambient light.        ; 
		this->ambientLight = vec3(f[1], f[2], f[3]);
    }

    else if (c == "brdf")  {
        // syntax: brdf  r g b   r g b  alpha
        // later:  brdf  r g b   r g b  alpha  r g b ior
        // First rgb is Diffuse reflection, second is specular reflection.
        // third is beer's law transmission followed by index of refraction.
        // Creates a Material instance to be picked up by successive shapes
        currentMat = new Material(vec3(f[1], f[2], f[3]), vec3(f[4], f[5], f[6]), f[7]); }

    else if (c == "light") {
        // syntax: light  x y z   
        // The position of the light source
        // Light color defaults to white     
        currentMat = new Light(vec3(f[1], f[2], f[3])); 		
    }
   
    else if (c == "sphere") {
        // syntax: sphere x y z   r
        // Creates a Shape instance for a sphere defined by a center and radius
        this->shapes.push_back(new Sphere(vec3(f[1], f[2], f[3]), f[4], currentMat)); 

        if (currentMat->isLight()) {
            lightPos = vec3(f[1], f[2], f[3]);
        }
    }

    else if (c == "box") {
        // syntax: box bx by bz   dx dy dz
        // Creates a Shape instance for a box defined by a corner point and diagonal vector
        this->shapes.push_back( new Box(vec3(f[1], f[2], f[3]), vec3(f[4], f[5], f[6]), currentMat)); }

    else if (c == "cylinder") {
        // syntax: cylinder bx by bz   ax ay az  r
        // Creates a Shape instance for a cylinder defined by a base point, axis vector, and radius
        this->shapes.push_back(new Cylinder(vec3(f[1], f[2], f[3]), vec3(f[4], f[5], f[6]), f[7], currentMat)); }


    else if (c == "mesh") {
        // syntax: mesh   filename   tx ty tz   s   <orientation>
        // Creates many Shape instances (one per triangle) by reading
        // model(s) from filename. All triangles are rotated by a
        // quaternion (qw qx qy qz), uniformly scaled by s, and
        // translated by (tx ty tz) .
        mat4 modelTr = translate(vec3(f[2],f[3],f[4]))
                          *scale(vec3(f[5],f[5],f[5]))
                          *toMat4(Orientation(6,strings,f));
        ReadAssimpFile(strings[1], modelTr);  }

    
    else {
        fprintf(stderr, "\n*********************************************\n");
        fprintf(stderr, "* Unknown command: %s\n", c.c_str());
        fprintf(stderr, "*********************************************\n\n");
    }
}

void Scene::TraceImage(Color* image, const int pass)
{    

#pragma omp parallel for schedule(dynamic, 1) // Magic: Multi-thread y loop
    for (int y=0;  y<height;  y++) {

        fprintf(stderr, "Rendering %4d\r", y);
        for (int x=0;  x<width;  x++) {
            Color color;

			// Iterate over all shapes in the scene to find the closest intersection
                         
            // Normalize pixel coordinates to screen space [0, 1] with pixel center sampling
            float u = (float)(x + 0.5f) / width;
            float v = (float)(y + 0.5f) / height; 

            // Calculate aspect ratio
            float aspectRatio = (float)width / (float)height;

            // Generate ray from camera through this pixel
            vec3 rayDir = camera->GetRayDirection(u, v, aspectRatio);
            Ray ray(camera->GetEye(), rayDir);

            // Find closest intersection with all shapes
            Intersection closest;
            closest.t = INF;
            
            // Trace time: 
            // 89423.45 ms
            // 89623.23 ms   
            // 89784.13 ms        
            /*for (Shape* shape : shapes) {
                auto hit = shape->intersect(ray);
                if (hit && hit->t < closest.t) {  // Avoid self-intersection with small epsilon
                    closest = *hit;
                }
            } */
            
            closest = accelStruc->intersect(ray);

            // Compute color based on closest intersection
            if (closest.t < INF) {
                // Ray hit a shape
                if (closest.shape->mat->isLight()) {
                    // Light source - return white
                    color = Color(1.0, 1.0, 1.0);
                }
                else {
                    // Regular material - calculate diffuse lighting
                    vec3 toLight = normalize(lightPos - closest.position);
                    float diffuse = std::max(0.0f, dot(closest.normal, toLight));
                    
                    // Combine material color with diffuse lighting
                    color = Color(closest.shape->mat->Kd.x * diffuse,
                                  closest.shape->mat->Kd.y * diffuse,
                                 closest.shape->mat->Kd.z * diffuse);

				    // Output just the diffuse component
                    //color = Color(closest.shape->mat->Kd.x,
                    //    closest.shape->mat->Kd.y,
                    //    closest.shape->mat->Kd.z);
                    
					// Display normal as color
                    //color = glm::abs(closest.normal);

					// Display t value as grayscale
                    // Normalize t to

                    // Normalize t to
					// Display t value as grayscale

                    //color = glm::abs(closest.normal);
					// Display normal as color
                    
                    //    closest.shape->mat->Kd.z);
                    //    closest.shape->mat->Kd.y,
                    //color = Color(closest.shape->mat->Kd.x,
				    // Output just the diffuse component

                                 closest.shape->mat->Kd.z * diffuse);
                                  closest.shape->mat->Kd.y * diffuse,
                    color = Color(closest.shape->mat->Kd.x * diffuse,
                    // Combine material color with diffuse lighting
                    
                    float diffuse = std::max(0.0f, dot(closest.normal, toLight));
                    vec3 toLight = normalize(lightPos - closest.position);
                    // Regular material - calculate diffuse lighting
                else {
                }
                    color = Color(1.0, 1.0, 1.0);
                    // Light source - return white
                if (closest.shape->mat->isLight()) {
                // Ray hit a shape
            if (closest.t < INF) {
            // Compute color based on closest intersection

            closest = accelStruc->intersect(ray);
            
            } */
                }
                    closest = *hit;
                if (hit && hit->t < closest.t) {  // Avoid self-intersection with small epsilon
                auto hit = shape->intersect(ray);
            /*for (Shape* shape : shapes) {
            // 89784.13 ms        
            // 89623.23 ms   
            // 89423.45 ms
            // Trace time: 
            
            closest.t = INF;
            Intersection closest;
            // Find closest intersection with all shapes

            Ray ray(camera->GetEye(), rayDir);
            vec3 rayDir = camera->GetRayDirection(u, v, aspectRatio);
            // Generate ray from camera through this pixel

            float aspectRatio = (float)width / (float)height;
            // Calculate aspect ratio

            float v = (float)(y + 0.5f) / height; 
            float u = (float)(x + 0.5f) / width;
            // Normalize pixel coordinates to screen space [0, 1] with pixel center sampling
                         
			// Iterate over all shapes in the scene to find the closest intersection

            Color color;
        for (int x=0;  x<width;  x++) {
        fprintf(stderr, "Rendering %4d\r", y);

    for (int y=0;  y<height;  y++) {
#pragma omp parallel for schedule(dynamic, 1) // Magic: Multi-thread y loop

{    
void Scene::TraceImage(Color* image, const int pass)

}
    }
        fprintf(stderr, "*********************************************\n\n");
        fprintf(stderr, "* Unknown command: %s\n", c.c_str());
        fprintf(stderr, "\n*********************************************\n");
    else {
    

        ReadAssimpFile(strings[1], modelTr);  }
                          *toMat4(Orientation(6,strings,f));
                          *scale(vec3(f[5],f[5],f[5]))
        mat4 modelTr = translate(vec3(f[2],f[3],f[4]))
        // translated by (tx ty tz) .
        // quaternion (qw qx qy qz), uniformly scaled by s, and
        // model(s) from filename. All triangles are rotated by a
        // Creates many Shape instances (one per triangle) by reading
        // syntax: mesh   filename   tx ty tz   s   <orientation>
    else if (c == "mesh") {


        this->shapes.push_back(new Cylinder(vec3(f[1], f[2], f[3]), vec3(f[4], f[5], f[6]), f[7], currentMat)); }
        // Creates a Shape instance for a cylinder defined by a base point, axis vector, and radius
        // syntax: cylinder bx by bz   ax ay az  r
    else if (c == "cylinder") {

        this->shapes.push_back( new Box(vec3(f[1], f[2], f[3]), vec3(f[4], f[5], f[6]), currentMat)); }
        // Creates a Shape instance for a box defined by a corner point and diagonal vector
        // syntax: box bx by bz   dx dy dz
    else if (c == "box") {

    }
        }
            lightPos = vec3(f[1], f[2], f[3]);
        if (currentMat->isLight()) {

        this->shapes.push_back(new Sphere(vec3(f[1], f[2], f[3]), f[4], currentMat)); 
        // Creates a Shape instance for a sphere defined by a center and radius
        // syntax: sphere x y z   r
    else if (c == "sphere") {
   
    }
        currentMat = new Light(vec3(f[1], f[2], f[3])); 		
        // Light color defaults to white     
        // The position of the light source
        // syntax: light  x y z   
    else if (c == "light") {

        currentMat = new Material(vec3(f[1], f[2], f[3]), vec3(f[4], f[5], f[6]), f[7]); }
        // Creates a Material instance to be picked up by successive shapes
        // third is beer's law transmission followed by index of refraction.
        // First rgb is Diffuse reflection, second is specular reflection.
        // later:  brdf  r g b   r g b  alpha  r g b ior
        // syntax: brdf  r g b   r g b  alpha
    else if (c == "brdf")  {

    }
		this->ambientLight = vec3(f[1], f[2], f[3]);
        // accurately *calculating* the true ambient light.        ; 
        // It will be ignored once your raytracer becomes capable of
        // Sets the ambient color.  Note: This parameter is temporary.
        // syntax: ambient r g b
    else if (c == "ambient") {


    }
		this->camera = new Camera(vec3(f[1], f[2], f[3]), Orientation(5, strings, f), f[4]);
        // Eye position (x,y,z),  view orientation (qw qx qy qz),  frustum height ratio ry        
        // syntax: camera x y z   ry   <orientation spec>
    else if (c == "camera") {

    }
        height = int(f[2]); 
        width = int(f[1]);
        // syntax: screen width height        
    if (c == "screen") {
    
    std::string c = strings[0];
    if (strings.size() == 0) return;
{
                    const std::vector<float>& f)
void Scene::Command(const std::vector<std::string>& strings,

}
    return q;
            i+=4; } }
            q *= angleAxis(f[i+0]*Radians, normalize(vec3(f[i+1], f[i+2], f[i+3])));
        else if (c == "a")  {
            i+=4; }
            q *= quat(f[i+0], f[i+1], f[i+2], f[i+3]);
        else if (c == "q")  {
            q *= angleAxis(f[i++]*Radians, Zaxis());
        else if (c == "z")  
            q *= angleAxis(f[i++]*Radians, Yaxis());
        else if (c == "y")  
            q *= angleAxis(f[i++]*Radians, Xaxis());
        if (c == "x")  
        std::string c = strings[i++];
    while (i<strings.size()) {
    quat q(1,0,0,0); // Unit quaternion
{
                        const std::vector<float>& f)
                        const std::vector<std::string>& strings,
quat Orientation(int i, 

}
            exit(-1); } }
            printf("\nRead error on file %s:\n  %s\n\n", path.c_str(), stbi_failure_reason());
        if (!image) {
        printf("%d %d %d %s\n", depth, width, height, path.c_str());
        image = stbi_load(path.c_str(), &width, &height, &depth, 4);
        stbi_set_flip_vertically_on_load(true);
        // Read image, and check for success
    else {
        exit(-1); }
        std::cerr << "Texture file not found: "  << path << std::endl;
    if (find_it.fail()) {
    std::ifstream find_it(path.c_str());
    // Does the file exist?
    
        path.replace(path.find(bs), 1, fs);}
    while (path.find(bs) != std::string::npos) {
    std::string fs="/";
    std::string bs="\\";
    std::string path=bpath;
    // Replace backslashes with forward slashes -- Good for Linux, and maybe Windows?
{
Texture::Texture(const std::string &bpath) : id(0)

}
    }
        this->shapes.push_back(new Triangle(v0, v1, v2, meshMat));
        // Create a Triangle shape and add it to the scene with the scene file's material
        
        vec3 v2 = mesh->vertices[tri[2]].pnt;
        vec3 v1 = mesh->vertices[tri[1]].pnt;
        vec3 v0 = mesh->vertices[tri[0]].pnt;
        // tri is an ivec3 containing three vertex indices
    for (const auto& tri : mesh->triangles) {
    // Convert mesh data into individual Triangle shapes and add to scene
    
    Material* meshMat = currentMat;
    // This allows the scene file to control mesh appearance
    // Use the currentMat from the scene file (set by brdf command)
{ 
void Scene::triangleMesh(MeshData* mesh) 

}
	this->accelStruc = new AccelerationBvh(this->shapes);
{
void Scene::Finit()

// Call myrandom(RNGen) to get a uniformly distributed random number in [0,1].
std::uniform_real_distribution<> myrandom(0.0, 1.0);
std::mt19937_64 RNGen(device());
std::random_device device;
#include <random>
// A good quality *thread-safe* Mersenne Twister random number generator.

#include "stb_image.h"
#define STBI_FAILURE_USERMSG
#define STB_IMAGE_IMPLEMENTATION

#include "raytrace.h"

////////////////////////////////////////////////////////////////////////
// Provides the framework for a raytracer.
//////////////////////////////////////////////////////////////////////

Project 1

Ray Casting

A ray caster for spheres, boxes, cylinders and triangle meshes over a BVH, with each stage checked by rendering it: nearest hit, ray distance, surface normals, and the hierarchy's speedup.

Course: CS 500, Ray Tracing
Submitted: 4 February 2026
Status: Complete

Project overview

The raytracer handles four primitives (spheres, boxes, cylinders, and triangle meshes), material properties through BRDF definitions, and texture mapping. Ray-shape intersections go through a Bounding Volume Hierarchy (BVH) instead of a loop over every shape in the scene.

Intersection calculation verification

Purpose

Check that intersection detection and nearest-hit selection are correct: that the closest intersection point (minimum t value) is the one returned, and that all valid intersections are considered before the frontmost one is picked.

Implementation

Each shape type (Sphere, Box, Cylinder, Triangle) has its own intersection algorithm. The scene is rendered with each pixel colored by the intersected object’s material diffuse color (the Kd component).

Verification method

Each primitive comes out in its assigned material color:

Spheres appear in their assigned Kd color
Boxes appear with their own distinct material properties
Cylinders and mesh triangles appear in their respective colors
Regions where no intersection occurs appear black (there are none in this scene)

Interpretation

A correct image means that:

Ray generation from camera coordinates is accurate
Each primitive’s intersection test identifies its hit points
Material assignment to shapes survives the intersection process
Object boundaries fall where the intersection algorithms put them

Test images

[Diffuse]

[Diffuse + Normal]

Ray parameter (t) verification

Purpose

Check that the ray parameter t (the distance along the ray direction) is correct at each intersection.

Implementation

In raytrace.cpp the distance is drawn as normalized grayscale, with maxDistance set to 10.0 for the scene scale:

float maxDistance = 10.0f;  // scene scale 
float normalizedT = std::min(1.0f, closest.t / maxDistance); 
color = Color(normalizedT, normalizedT, normalizedT);

Verification method

Objects closer to the camera appear darker, since a smaller t gives a lower pixel intensity
Objects farther from the camera appear brighter, since a larger t gives a higher intensity
Gradual grayscale transitions across object surfaces confirm continuous t calculation
Shadow boundaries and occluded regions show the expected depth relationships

Interpretation

A correct t-value image means:

Ray direction vectors are normalized
The parametric ray equation P(t) = origin + t * direction is evaluated correctly
Closest intersection filtering (closest.t < INF) selects the nearest hits
Depth relationships between objects are geometrically accurate

Test image

Surface normal verification

Purpose

Check that surface normals at intersection points are calculated correctly.

Implementation

The shading is replaced by the normal itself, in raytrace.cpp (line 235):

// Display normal as color 
color = glm::abs(closest.normal);

Each component of the normal vector becomes an RGB channel, with absolute values so the colors stay positive.

Verification method

Sphere normals: radiate outward from the center, which gives symmetric gradient patterns
Box normals: perpendicular to each face, so 3 distinct normal directions show
Cylinder normals: vary smoothly around the curved surface, constant on the end caps
Mesh triangles: normals per face, or interpolated across vertices for smooth shading

Interpretation

A correct normal image confirms:

Each primitive’s geometric normal calculation is accurate
Normal vectors point outward from the surface
Normals are normalized to unit length
For meshes, vertex normal interpolation produces smooth shading
Lighting calculations built on them will be geometrically valid

Test image

Bounding box hierarchy validation

Purpose

Check the bounding box hierarchy and the ray-box intersection by rendering the scene geometry at bounding box level instead of at shape level, and confirm that each bounding box (AABB) encloses the geometry inside it.

Implementation overview

The bounding box extends the one from the BVH v2 library (bvh::v2::Bvh:BBox), in bbox.h. Each SimpleBox wraps the library’s bounding box and extends it with individual vertices or with other bounding boxes, which keeps the bounds tight around the geometry.

The bounding box intersection is the same for every shape, so the logic lives in shape.h, the parent class of all of them.

The shape intersection is replaced with the bounding box intersection in acceleration.cpp (line 45):

// Render scene at bounding box level instead of actual shapes
auto result = shape->intersectBoundingBox(ray);

Instead of calling shape->intersect(ray), which traces rays against the actual geometry, this returns intersection data from the axis-aligned bounding box (AABB) that encloses each shape. The intersection point, normal, and the other properties come from the box surface rather than from the primitive.

Verification method

Box normals: 3 distinct normal directions, perpendicular to each of the 6 faces
Layered boxes: multiple overlapping boxes become visible, which is the acceleration hierarchy
Ray coverage: all rays that intersect actual shapes also intersect their bounding boxes (superset verification)

Interpretation

A correct bounding box image confirms:

Bounding box calculations enclose all the geometry within each shape
Box-ray intersection tests are geometrically valid
BVH acceleration structure bounds are computed correctly

Test images

[Normal]

[Diffuse ]

[Diffuse + Normal]

[T-Value]

Spatial data structure performance verification

Purpose

Measure how much the BVH acceleration structure speeds up a render.

Implementation overview

The raytracer uses the BVH v2 library (bvh::v2::Bvh) with axis-aligned bounding boxes. Every shape is wrapped in a BvhShape, and those are loaded onto the BVH builder. Two builders were timed: MiniTreeBuilder (multi threaded) and SweepSahBuilder (single threaded).

Performance measurement

traceImage is wrapped in a timing function measureTimeMs, which measures how long the call takes and prints it at the end (main.cpp line 126):

  double renderTime = measureTimeMs([&]() {
      // RayTrace the image
      scene->TraceImage(image, 1);
  });

Speedup analysis

Simple objects scene

Run timing with only basic primitives (few spheres/boxes):

Result: minimal speedup
Reason: BVH construction and traversal overhead dominates with few objects
Trade-off: the acceleration structure’s overhead exceeds the benefit of culling

Complex scene

Run with Dwarf model:

Expected speedup: somewhat observable
Performance gain: the BVH reduces intersection tests per ray, especially with the dwarf model

Run with Dwarf and Stanford Bunny:

Expected speedup: significant speedup observed (approx 119%)
Performance gain: the BVH cuts the intersection tests per ray sharply
Scalability: speedup increases proportionally with object count

Measurements

Method	Trial 1	Trial 2	Trial 3	Builder Type
Non-BVH	89423.45 ms	89623.23 ms	89784.13 ms	N/A
SweepSahBuilder	130.44ms	132.91ms	136.96ms	SAH optimization
MiniTreeBuilder	111.41ms	109.23ms	110.55ms	ThreadPool-optimized

Overall the BVH gives approx. 200% improvement over the non-BVH implementation, and MiniTreeBuilder renders ~18% faster than SweepSahBuilder (130-137ms) at similar quality.

Code implementation

The Scene::Finit() function initializes the acceleration structure:

void Scene::Finit() { this->accelStruc = new AccelerationBvh(this->shapes); }

AccelerationBvh (lines 78-93) sets up the builders used for the BVH, and TraceImage uses accelStruc to compute the intersection record for each ray.

Interpretation

For simple scenes: the BVH overhead may exceed the benefit; consider disabling it for minimal geometry
For complex meshes (bunny, dragon, etc.), the speedup confirms the BVH is worth its overhead
Acceleration structure: scene space is partitioned using bounding boxes
Ray traversal: the BVH identifies the relevant primitives
Performance improvement: validates the spatial data structure implementation
Scalability: O(log n) behavior rather than the naive O(n) approach

Summary

The raytracer:

Computes accurate ray-primitive intersections with correct geometry
Calculates correct t-values representing distances along rays in world space
Generates accurate surface normals for lighting calculations
Implements acceleration structures for the complex scenes that need them

Class structure

Core geometry and intersection

Ray

A 3D ray with an origin and a normalized direction vector. evaluate(t) returns the point along the ray at parameter distance t.

Intersection

The data for one ray-shape intersection: hit distance t, intersection position, surface normal, and a reference to the intersected shape. Has a distance getter for the hit parameter.

Interval

An interval along a ray, with minimum and maximum t-values and their associated normals. Used internally for slab-based intersection testing in boxes and cylinders.

Geometric primitives

Shape

Abstract base class for all geometric primitives in the scene. Defines the interface for ray intersection, bounding box computation, and material association.

Sphere

A sphere defined by a center position and a radius. Solves the quadratic equation for the ray-sphere intersection and computes the surface normal from the hit.

Box

An axis-aligned bounding box (AABB) defined by a corner and a diagonal vector. Uses the slab intersection method for ray-box collision detection.

Cylinder

A cylinder with a base position, an axis direction, and a radius. Uses a coordinate transformation and interval testing to compute the ray-cylinder intersection.

Triangle

A triangular polygon defined by three vertices (v0, v1, v2). Uses the Möller-Trumbore algorithm for the ray-triangle intersection.

Material and texture system

Texture

Wraps image texture data loaded from a file path with the STB image library. Stores the image dimensions (width, height, depth) and the pixel data used for surface detail mapping.

Material

Base class for surface shading properties: diffuse (Kd), specular (Ks), and shininess (alpha) coefficients. Can optionally reference a texture, and identifies light-emitting materials.

BRDFMaterial

Extends Material with the BRDF (Bidirectional Reflectance Distribution Function) implementation. Inherits the diffuse, specular, and alpha properties for physically-based shading.

Light

A Material subclass for emissive surfaces, with the radiance value stored in Kd. Overrides isLight() to return true, so the renderer handles it as a light.

Camera system

Camera

Holds the camera position, orientation (quaternion), and frustum properties. Transforms normalized screen coordinates into world-space ray directions using the camera orientation.

Acceleration structures

SimpleBox

A bounding box wrapper extending the BVH library’s BBox<float, 3> with GLM vector compatibility. Has construction and extension methods for building the spatial structure.

BvhShape

Adapter class wrapping a Shape* pointer for the BVH library. Passes bounding box and intersection queries to the underlying Shape, converting between coordinate systems.

AccelerationBvh

Builds and traverses the BVH (Bounding Volume Hierarchy) for accelerated ray-scene intersection. Wraps all scene shapes and runs the closest-hit queries against the spatial partitioning.

Scene management

VertexData

Per-vertex geometry data: position, normal, texture coordinates, and tangent vector. Used by the mesh loading system for vertex attribute storage.

MeshData

Container for mesh geometry, with a vertex array and indexed triangle connectivity. Associates the mesh data with a material, so one set of surface properties applies across it.

Scene

Holds the complete ray-traced scene: camera, shapes, materials, lighting, and acceleration structure. Parses scene files, loads mesh data, and provides the TraceImage() interface for image generation.