Bulbit

Bulbit is a physically based raytracing renderer.

Features

Here are the rendering algorithms implemented in Bulbit.

Integrator

Unidirectional integrators
- Path tracing with NEE and continuation ray MIS
- Volumetric path tracing
- Light tracing and Volumetric light tracing
- Naive versions of above algorithms
Bidirectional integrators
- Bidirectional path tracing with MIS
- Volumetric BDPT
- Vertex Connection and Merging
Photon mapping integrators
- Original photon mapping and Volumetric photon mapping
- Stochastic Progressive Photon Mapping
- Volumetric SPPM
ReSTIR integrators
- Unbiased ReSTIR with hybrid shift (delayed reconnection)
- GRIS with pairwise MIS
- ReSTIR Direct lighting
- ReSTIR Path tracing
Others
- Random walk ray tracing
- Whitted style ray tracing
- Ambient occlusion

Light

Light sources
- Point, Spot and Directional light
- Diffuse, Spot and Directional area light
Light samplers
- Uniform light sampler, Power light sampler

Material

BSDF
- Lambertian and Specular reflection BRDF
- Dielectric and Conductor BSDF
- Energy compansating multi-scattering dielectic and conductor BSDF
- Thin dielectric BSDF
- Metallic-Roughness BRDF
- Energy-preserving Oren–Nayar(EON) BRDF
- Charlie Sheen BRDF
- Substrate BRDF
  - Rough dielectric coat on diffuse substrate, with volume layer between them
- Principled BSDF
  - Support several GLTF 2.0 extensions
  - Clearcoat, transmission, dielectic, conductor, sheen and diffuse
- Layered BSDF
BSSRDF
- Christensen-Burley BSSRDF (Exponential fits)
- Volumetric random walk based BSSRDF

Participating Media

Null-scattering path integral formulation
Sampling volume scattering with majorant transmittance
Spectral/Wavelength MIS
Homogeneous medium
Nano VDB medium (density and temperature grid)

Geometry

Shape
- Sphere and Triangle mesh
Acceleration Structure
- SAH based BVH and Dynamic BVH

Camera

Perspective, Orthographic and Spherical camera
Depth of field
Reconstruction filters
- Box, Tent and Gaussian filter

Building

Install CMake
Ensure CMake is in your system PATH

Clone the repository

git clone https://github.com/Sopiro/Bulbit

Build the project
The CLI application bbcli will be built by default (BULBIT_BUILD_CLI=ON).
```
mkdir build
cd build
cmake ..
cmake --build .
```

Showcase

Conductor materials with physical parameters

LTE Orb model courtesy of MirageYM

Subsurface Scattering with Random walk BSSRDF

Dragon model courtesy of Stanford Graphics Lab.

Volumetric caustics rendered with Volumetric BDPT

SDS path rendered with Vertex Connection and Merging

Bunny model courtesy of Stanford Graphics Lab.

Nano VDB volume rendered with volumetric path tracer

Cloud volume courtesy of Disney

ReSTIR PT 1spp spatial_radius=20 spatial_samples=10, no temporal reuse

Country kitchen scene courtesy of Jay-Artist

Experimental Spectral Rendering

Bulbit as a standalone library

You can embed Bulbit directly in your own C++ app and build a scene in code.
The example below renders a sphere lit by a spot light.

#include "bulbit/bulbit.h"

int main()
{
    using namespace bulbit;

    uint32 num_threads = std::thread::hardware_concurrency();
    ThreadPool::global_thread_pool = std::make_unique<ThreadPool>(num_threads);

    Scene scene;

    // Create texture, material and sphere primitive
    Texture<Spectrum>* tex =
      scene.CreateTexture<ConstantTexture, Spectrum>(Spectrum(0.85f, 0.2f, 0.2f));
    Material* mat = scene.CreateMaterial<DiffuseMaterial>(tex);
    Point3 sphere_pos(0.0f, 1.0f, 0.0f);
    Shape* sphere = scene.CreateShape<Sphere>(sphere_pos, 1.0f);
    scene.CreatePrimitive(sphere, mat, MediumInterface{});

    // Create two lights
    Point3 light_pos(2.5f, 4.0f, 2.0f);
    Vec3 light_dir = Normalize(light_pos - sphere_pos);
    scene.CreateLight<SpotLight>(light_pos, light_dir, Spectrum(80.0f), 35.0f, 20.0f, nullptr);
    scene.CreateLight<UniformInfiniteLight>(Spectrum(0.1f));

    // Create camera
    Point3 camera_pos(3.0f, 2.0f, 5.0f);
    Point2i resolution(1280, 720);
    Float fov = 35;
    Float aperture = 0.01f;

    BoxFilter filter;
    PerspectiveCamera camera(
        Transform::LookAt(camera_pos, sphere_pos, y_axis),
        fov, aperture, Dist(camera_pos, sphere_pos),
        resolution, nullptr, &filter
    );

    // Build acceleration structure
    BVH accel(scene.GetPrimitives());

    // Create integrator
    int spp = 16;
    int max_bounces = 8;
    IndependentSampler sampler(spp);
    PathIntegrator integrator(&accel, scene.GetLights(), &sampler, max_bounces);

    // Render!
    Allocator alloc;
    Rendering* rendering = integrator.Render(alloc, &camera);
    rendering->WaitAndLogProgress();
    WriteImage(rendering->GetFilm().GetRenderedImage(), "render.jpg");
    alloc.delete_object(rendering);

    return 0;
}

This will produce render.jpg. For practical use cases, see the CLI application.

Sopiro/Bulbit