Understanding the Pipeline

Section 1

Global Illumination & Path Tracing

Global illumination (GI) simulates how light bounces between surfaces, creating soft shadows, color bleeding, and realistic ambient lighting. Unlike rasterization (which only computes direct lighting), GI accounts for all light paths.

The Rendering Equation

All physically-based rendering solves the same equation, formulated by James Kajiya in 1986:

In words: outgoing light = emitted light + integral of (BRDF × incoming light × cosine) over hemisphere.

Path Tracing

Genesis uses Monte Carlo path tracing to solve this integral stochastically:

// Simplified path tracing
for sample in 1..SPP:
    ray = camera.generate_ray(pixel)
    color = trace_path(ray, depth=12)
    
def trace_path(ray, depth):
    hit = scene.intersect(ray)
    if hit.material.is_emissive:
        return hit.emission
    
    wi = hit.material.sample(wo, normal)
    Li = trace_path(Ray(hit.point, wi), depth - 1)
    return brdf * Li * cos(theta) / pdf

Section 2

Physically-Based Materials

Every surface has a material defining how light interacts with it. Modern renderers use PBR—materials based on real physics, not arbitrary parameters.

Section 3

Reflection: BRDF & Fresnel

The BRDF describes what fraction of incoming light reflects in each outgoing direction. For metals, most light reflects; for dielectrics, the Fresnel equations determine reflection vs. transmission.

Fresnel Equations

All materials reflect more light at grazing angles:

Section 4

Refraction: Snell's Law

When light crosses a boundary (air → glass), it bends according to Snell's Law:

Section 5

Camera: DOF & Bokeh

Genesis simulates a thin-lens camera. Objects at the wrong distance appear blurry—just like a real camera.

Section 6

OIDN Denoising

Even at 128 SPP, Monte Carlo noise is visible. We use Intel Open Image Denoise (OIDN)—a neural network trained to remove path tracing noise while preserving detail.

# HDR denoising pipeline
rgb_float = camera.render()        # float32 [0, ∞)
rgb_float = clip(rgb_float, 0, 1)
rgb_clean = denoiser.denoise(rgb_float)  # OIDN Metal
rgb_uint8 = (rgb_clean * 255).astype(uint8)

Section 7

Rigid Body Simulation

The domino cascade isn't animated by hand—it's simulated. Genesis solves Newton's equations of motion at 60 Hz.

# Collision response
for (A, B) in find_collisions():
    v_rel = A.velocity - B.velocity
    impulse = -(1 + restitution) * dot(v_rel, normal) / 
              (1/A.mass + 1/B.mass)
    
    A.velocity += impulse * normal / A.mass
    B.velocity -= impulse * normal / B.mass

Section 9

Forge: The Cinematography Engine

Forge is Kagami's construction colony—the engine that abstracts camera movements into composable, named shot types.

from kairos.core.services.forge.modules.genesis.cinematography import (
    Cinematographer, Shot, Sequence,
)

sequence = Sequence(
    name="The Symmetry of Collapse",
    shots=[
        Cinematographer.create_one_point_perspective_shot(...),
        Cinematographer.create_rack_focus_shot(...),
        Cinematographer.create_dolly_zoom_shot(...),
        Cinematographer.create_steadicam_follow_shot(...),
        Cinematographer.create_arc_shot(...),
    ]
)

Section 10

World Model Integration

How does this connect to Kagami's world model? Genesis provides the substrate for imagination—the world model can predict "what happens if I push this domino?" and Genesis makes that prediction visible.