Home / Features

Features

Geometry, acceleration structures, lighting, materials and interactive tools available in the engine. Everything on this page reflects the project's actual code (scene parser, builders, material headers).

Primitives

Ten primitive types are recognized by the parser (SceneParser) and constructed by the PrimitiveBuilder. Each primitive implements the IPrimitive interface (intersection test, bounding box, material, properties). The type column is the value of the "type" key in the JSON scene file.

Acceleration geometry (AABB / BVH)

Two helper structures back the rendering: AABB (axis-aligned bounding box) and BVH (bounding volume hierarchy). Every primitive exposes its bounding box, which lets it be placed in the BVH and lets rays that miss it be rejected quickly. The construction is detailed in the BVH acceleration section.

Lights

Two light types are supported by the parser and builders. Each light implements ILight (intensity, color) and is evaluated as direct lighting by the active renderer's model.

Shadows

For each light and each hit point H, the engine casts a shadow ray from a slightly offset origin (H + ε·N, where N is the surface normal) toward the light:

• For a point light, the ray is a segment limited to the light distance (t_max = d − ε).
• For a directional light, the ray goes toward −direction with t_max = +∞.

If an occluder blocks the path before t_max, that light's direct contribution is discarded for this point; otherwise the diffuse and specular terms are evaluated. The offset ε along the normal prevents shadow acne (the surface self-intersecting).

Materials

Materials (srcs/common/Material.hpp) follow one of two shading models: PHONG (default) or PBR. They carry a name and are referenced by that name from scene objects. The table below lists all fields of the Material struct with their actual default values.

Material library

Materials can be saved to a personal library (MaterialLibrary) located in ~/.raytracer/materials/. Each material is stored as a <name>.json file (the name is sanitized: non-alphanumeric characters become _). loadAll() reads every .json in the folder and sorts them by name.

Reflections and transparency

The material fields reflectivity, transparency and ior control mirror reflection, transparency and refraction respectively. They rely on secondary rays spawned from the hit point: a reflection ray and a refraction ray, cast with an ε offset to avoid self-intersection. The ior (index of refraction) determines how the transmitted ray bends at the interface.

BVH acceleration

Before rendering, the scene builds a bounding volume hierarchy (BVHNode, via scene.buildBvh()). Each node holds a bounding box (AABB); a ray that misses a node's box skips its entire subtree, greatly reducing the number of intersection tests on busy scenes. Meshes additionally have a local BVH built over their triangles, rebuilt when a vertex is edited (see Vertex editing).

Meshes and .obj import

A mesh loads a Wavefront .obj file (via ObjParser), derives triangles (MeshTriangle), computes smooth normals (average of incident faces) and builds a local BVH. A mesh can also be defined inline in the scene via vertices / faces / normals, allowing it to be serialized without an external file.

{
    "name": "Suzanne",
    "type": "mesh",
    "file": "tests/obj/suzanne.obj",
    "position": [0.0, 0.0, 0.0],
    "rotation": [0.0, 0.0, 0.0],
    "scale": [1.0, 1.0, 1.0],
    "material": "Blue"
}

Vertex editing

Primitives that implement IEditablePrimitive (in addition to IPrimitive) can have their vertices moved directly in the viewport. Editable primitives:

Analytic primitives (cube, sphere, plane, cylinder, cone, torus, tanglecube, fractal) are not vertex-editable: select one and use Convert to Mesh to turn it into a triangle mesh, then edit it. A cube is baked exactly to 8 vertices / 12 triangles; other shapes are sampled (an infinite plane cannot be converted).

Mesh edits are stored as vertex overrides (vertex_overrides, in object space) re-applied after the .obj is loaded; the .obj file is never modified. After each edit the BVH is flagged for rebuild and the viewport updates.

Cluster rendering

The engine can distribute a render across several machines: a server splits the image into tiles and hands them to connected clients, which send their pixels back. A server is started with --server [PORT] and joined with --connect IP PORT. Communication uses typed packets (join, scene push, render request, tile upload, render state). See Architecture → Cluster.