dymokomi/luce-render
Source of release 0.1.3
0.1.3 / tests / gpu / integrator.lucb
## The integrator against answers known in closed form:
## - a white furnace: a white diffuse sphere under a uniform white background
## is exactly the background everywhere, in both builds;
## - a square area light over a grey plane: the radiance straight below its
## center is albedo / π × the rectangle's irradiance, with light paths too;
## - spectral against RGB: a colored light (and a blackbody) on a white plane
## agree between the builds within the spectral upsampling's error.
import memory
from luce_std import math
from luce_std import clock
from luce_gpu import gpu
from luce_render import render
from luce_geocore.geocore import Vector3, Mesh, MeshPrimitives, GeometrySet, MaterialAssignment, AttributeKernels
from luce_png import png
import interop
import c
from luce_std import files
from io import path
from luce_exr import exr
from luce_raster.model import Raster, SampleType
from luce_raster.binary import Buffer
from luce_geocore.core.growing import Growing
from luce_geocore.kernel import append_text
pub func checks(device: gpu.Device) -> !:
try furnace(device, true, 0.0)
try furnace(device, false, 0.0)
try furnace(device, true, 1.0)
try metal_furnace(device, true, 0.5)
try metal_furnace(device, false, 1.0)
try layer_furnace(device, true, 1)
try layer_furnace(device, false, 2)
try layer_furnace(device, true, 2)
try layer_furnace(device, true, 3)
try cutout(device)
try emission(device, false)
try emission(device, true)
try assigned_materials(device)
try area_light(device, true, 0.0)
try area_light(device, false, 0.0)
try area_light(device, true, 1.0)
try area_light(device, false, 0.5)
try emissive_quad(device, true, 0.0)
try emissive_quad(device, false, 0.0)
try emissive_quad(device, true, 1.0)
try lit_room(device)
try thin_lens(device)
try dome_furnace(device, true)
try dome_furnace(device, false)
try dome_sun(device, true)
try dome_sun(device, false)
try textured_floor(device, true)
try textured_floor(device, false)
try graph_nodes(device, true)
try graph_nodes(device, false)
try bump_slope(device)
try viewed_graph(device, false)
try viewed_graph(device, true)
try cutout_shadow(device)
try adaptive(device)
try guided_room(device)
try spectral_agrees(device, 0.0)
try spectral_agrees(device, 3000.0)
try hardware_agrees(device)
try timing(device)
## Mean of the image's rgb over a window of pixels.
func window_mean(pixels: const f32[], width: usize, x0: usize, y0: usize, size: usize) -> Vector3:
var sum = Vector3()
for y in y0..<y0 + size:
for x in x0..<x0 + size:
let at = (y * width + x) * 4
sum = sum.add(Vector3((f64)pixels[at], (f64)pixels[at + 1], (f64)pixels[at + 2]))
return sum.multiply_scalar(1.0 / (f64)(size * size))
func rendered(device: gpu.Device, set: const GeometrySet*, settings: render.RenderSettings, out: f32[]) -> !:
var scene = try render.compile_scene(set)
defer scene.close()
var renderer = try render.Renderer.create(device, &scene, settings)
defer renderer.destroy()
try renderer.finish()
assert(renderer.samples_done() == settings.samples)
try renderer.read(out)
## `roughness` is EON's: at 1 its multiple scattering must still make a white
## surface reflect everything.
func furnace(device: gpu.Device, spectral: bool, roughness: f64) -> !:
let sphere = try MeshPrimitives.sphere(1.0, 32)
defer sphere.release()
let base = try GeometrySet.of_mesh(sphere)
defer base.release()
let set = try base.value().with_camera("/camera", Vector3(0.0, 1.0, 4.0), Vector3(), 0, 50.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer set.release()
var settings = render.RenderSettings.of(64, 48, 64)
settings.spectral = spectral
settings.max_bounces = 64
settings.background = Vector3(1.0, 1.0, 1.0)
settings.material.base_color = Vector3(1.0, 1.0, 1.0)
settings.material.base_diffuse_roughness = roughness
# The rough run guides too: guided sampling must keep the furnace white.
settings.guiding = roughness == 1.0
let pixels = try new f32[64 * 48 * 4] --- in memory.heap
defer free(pixels) in memory.heap
try rendered(device, set.value(), settings, pixels)
let mean = window_mean(pixels, 64, 0, 0, 48)
let center = window_mean(pixels, 64, 24, 16, 16)
if math.abs(mean.x - 1.0) > 0.01 or math.abs(mean.y - 1.0) > 0.01 or math.abs(mean.z - 1.0) > 0.01 or math.abs(center.y - 1.0) > 0.02:
print(f"furnace (spectral {spectral}, roughness {roughness}): mean {mean.x} {mean.y} {mean.z}, on the sphere {center.x} {center.y} {center.z}")
assert(false)
## A white metal (F0 = 1) of any roughness reflects everything: multiple
## scattering between microfacets is restored by the energy compensation.
func metal_furnace(device: gpu.Device, spectral: bool, roughness: f64) -> !:
let sphere = try MeshPrimitives.sphere(1.0, 32)
defer sphere.release()
let base = try GeometrySet.of_mesh(sphere)
defer base.release()
let set = try base.value().with_camera("/camera", Vector3(0.0, 1.0, 4.0), Vector3(), 0, 50.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer set.release()
var settings = render.RenderSettings.of(64, 48, 64)
settings.spectral = spectral
settings.max_bounces = 64
settings.background = Vector3(1.0, 1.0, 1.0)
settings.material.base_color = Vector3(1.0, 1.0, 1.0)
settings.material.base_metalness = 1.0
settings.material.specular_roughness = roughness
let pixels = try new f32[64 * 48 * 4] --- in memory.heap
defer free(pixels) in memory.heap
try rendered(device, set.value(), settings, pixels)
let center = window_mean(pixels, 64, 24, 16, 16)
if math.abs(center.y - 1.0) > 0.02:
print(f"metal furnace (spectral {spectral}, roughness {roughness}): on the sphere {center.x} {center.y} {center.z}")
assert(false)
## Under a white sky: a white base under a clear coat (`kind` 1), and a closed
## sphere of smooth glass (2), and of dispersive glass (3: its wavelengths
## split and the hero carries the sample), are white: the coat's darkening
## vanishes over a white base, and glass loses nothing between Fresnel,
## refraction and total internal reflection.
func layer_furnace(device: gpu.Device, spectral: bool, kind: i64) -> !:
let sphere = try MeshPrimitives.sphere(1.0, 48)
defer sphere.release()
let base = try GeometrySet.of_mesh(sphere)
defer base.release()
let set = try base.value().with_camera("/camera", Vector3(0.0, 1.0, 4.0), Vector3(), 0, 50.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer set.release()
var settings = render.RenderSettings.of(64, 48, 64)
settings.spectral = spectral
settings.max_bounces = 64
settings.background = Vector3(1.0, 1.0, 1.0)
settings.material.base_color = Vector3(1.0, 1.0, 1.0)
if kind == 1:
settings.material.coat_weight = 1.0
settings.material.coat_roughness = 0.3
else:
settings.material.transmission_weight = 1.0
settings.material.specular_roughness = 0.0
if kind == 3:
settings.material.transmission_dispersion_scale = 1.0
settings.material.transmission_dispersion_abbe_number = 10.0
settings.samples = 1024
let pixels = try new f32[64 * 48 * 4] --- in memory.heap
defer free(pixels) in memory.heap
try rendered(device, set.value(), settings, pixels)
let center = window_mean(pixels, 64, 24, 16, 16)
if math.abs(center.y - 1.0) > 0.02:
print(f"{"coat" if kind == 1 else ("glass" if kind == 2 else "dispersive glass")} furnace (spectral {spectral}): on the sphere {center.x} {center.y} {center.z}")
assert(false)
## A sphere emitting 3 nits at opacity one half, in the dark: half the rays stop
## at its front and see 3, a quarter pass to its back face and see 3 there, so
## it shows 2.25.
func cutout(device: gpu.Device) -> !:
let sphere = try MeshPrimitives.sphere(1.0, 32)
defer sphere.release()
let base = try GeometrySet.of_mesh(sphere)
defer base.release()
let set = try base.value().with_camera("/camera", Vector3(0.0, 1.0, 4.0), Vector3(), 0, 100.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer set.release()
var settings = render.RenderSettings.of(32, 32, 256)
settings.spectral = false
settings.material.emission_luminance = 3.0
settings.material.geometry_opacity = 0.5
settings.material.base_color = Vector3(0.0, 0.0, 0.0)
settings.material.specular_weight = 0.0
let pixels = try new f32[32 * 32 * 4] --- in memory.heap
defer free(pixels) in memory.heap
try rendered(device, set.value(), settings, pixels)
let center = window_mean(pixels, 32, 12, 12, 8)
if math.abs(center.y - 2.25) > 0.05:
print(f"cutout: {center.x} {center.y} {center.z}")
assert(false)
## A sphere of emission luminance 3 and a reddish color in the dark shows its
## emission exactly; the base reflects nothing, as nothing else lights it.
func emission(device: gpu.Device, spectral: bool) -> !:
let sphere = try MeshPrimitives.sphere(1.0, 32)
defer sphere.release()
let base = try GeometrySet.of_mesh(sphere)
defer base.release()
# The primitive sphere's center is at y = 1.
let set = try base.value().with_camera("/camera", Vector3(0.0, 1.0, 4.0), Vector3(), 0, 100.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer set.release()
var settings = render.RenderSettings.of(32, 32, 16)
settings.spectral = spectral
settings.material.emission_luminance = 3.0
settings.material.emission_color = Vector3(1.0, 0.5, 0.25)
let pixels = try new f32[32 * 32 * 4] --- in memory.heap
defer free(pixels) in memory.heap
try rendered(device, set.value(), settings, pixels)
let center = window_mean(pixels, 32, 12, 12, 8)
if math.abs(center.x - 3.0) > 0.03 or math.abs(center.y - 1.5) > 0.02 or math.abs(center.z - 0.75) > 0.02:
print(f"emission (spectral {spectral}): {center.x} {center.y} {center.z}")
assert(false)
## Two spheres in the dark: the left assigned an emissive red material by its
## faces' `material` attribute, the right on the default material. Only the
## left glows; an unknown path falls back to the default.
func assigned_materials(device: gpu.Device) -> !:
let sphere = try MeshPrimitives.sphere(1.0, 24)
defer sphere.release()
let red_faces = try MaterialAssignment.faces(sphere, "", "material", "materials/red")
defer red_faces.release()
let unknown_faces = try MaterialAssignment.faces(sphere, "", "material", "materials/missing")
defer unknown_faces.release()
let left = try (try GeometrySet.of_mesh(red_faces)).value().transformed(Vector3(-1.2, 0.0, 0.0), Vector3(), Vector3(1.0, 1.0, 1.0))
defer left.release()
let right = try (try GeometrySet.of_mesh(unknown_faces)).value().transformed(Vector3(1.2, 0.0, 0.0), Vector3(), Vector3(1.0, 1.0, 1.0))
defer right.release()
let both = try left.value().merged(right)
defer both.release()
let library = try both.value().with_material("materials/red", "openpbr", "emission_luminance\nemission_color", [2.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0])
defer library.release()
let set = try library.value().with_camera("/camera", Vector3(0.0, 1.0, 6.0), Vector3(), 0, 35.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer set.release()
# RGB: pure ACEScg red has no smooth spectrum, so the spectral build is
# close but not exact.
var settings = render.RenderSettings.of(48, 32, 4)
settings.spectral = false
let pixels = try new f32[48 * 32 * 4] --- in memory.heap
defer free(pixels) in memory.heap
try rendered(device, set.value(), settings, pixels)
let glowing = window_mean(pixels, 48, 12, 14, 4)
let dark = window_mean(pixels, 48, 32, 14, 4)
# The right sphere does not glow; it only catches a little of the left's light.
if math.abs(glowing.x - 2.0) > 0.03 or glowing.y > 0.01 or dark.x > 0.05:
print(f"assigned materials: left {glowing.x} {glowing.y} {glowing.z}, right {dark.x} {dark.y} {dark.z}")
assert(false)
## The irradiance at a point under the corner of an x × y rectangle of radiance
## 1 at height h, parallel to the receiving plane.
func corner_irradiance(x: f64, y: f64, h: f64) -> f64:
let a = math.sqrt(x * x + h * h)
let b = math.sqrt(y * y + h * h)
return 0.5 * (x / a * math.atan(y / a) + y / b * math.atan(x / b))
## The same square as an emissive mesh (two triangles, light sampled through
## the light tree, two-sided) lights the floor below it as the rect light does.
func emissive_quad(device: gpu.Device, spectral: bool, light_tracing: f64) -> !:
let floor = try MeshPrimitives.grid(20.0, 8)
defer floor.release()
let square = try MeshPrimitives.grid(1.0, 1)
defer square.release()
let glowing = try MaterialAssignment.faces(square, "", "material", "materials/glow")
defer glowing.release()
let lamp = try (try GeometrySet.of_mesh(glowing)).value().transformed(Vector3(0.0, 1.0, 0.0), Vector3(), Vector3(1.0, 1.0, 1.0))
defer lamp.release()
let both = try (try GeometrySet.of_mesh(floor)).value().merged(lamp)
defer both.release()
let library = try both.value().with_material("materials/glow", "openpbr", "emission_luminance\nbase_weight\nspecular_weight", [4.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
defer library.release()
let pitch = -math.atan2(0.5, 3.0)
let set = try library.value().with_camera("/camera", Vector3(0.0, 0.5, 3.0), Vector3(pitch, 0.0, 0.0), 0, 200.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer set.release()
# Light paths land on the measured pixels a few a sample: they need more.
var settings = render.RenderSettings.of(32, 32, 256 if light_tracing == 0.0 else 4096)
settings.spectral = spectral
settings.max_bounces = 1
settings.light_tracing = light_tracing
settings.material.base_color = Vector3(0.5, 0.5, 0.5)
settings.material.specular_weight = 0.0
let pixels = try new f32[32 * 32 * 4] --- in memory.heap
defer free(pixels) in memory.heap
try rendered(device, set.value(), settings, pixels)
let measured = window_mean(pixels, 32, 14, 14, 4)
let expected = 0.5 / math.pi * 4.0 * 4.0 * corner_irradiance(0.5, 0.5, 1.0)
if math.abs(measured.y / expected - 1.0) > 0.02:
print(f"emissive quad (spectral {spectral}, light paths {light_tracing}): {measured.x} {measured.y} {measured.z}, expected {expected}")
assert(false)
## A 3 × 3 sheet between the rect light and the floor, reflecting nothing
## itself: at opacity one half it passes exactly half of what it passes when
## fully transparent. Shadow rays walk through cut-outs keeping (1 - opacity),
## BSDF rays pass at random, and MIS weighs both from the floor.
func cutout_shadow(device: gpu.Device) -> !:
let floor = try MeshPrimitives.grid(20.0, 8)
defer floor.release()
let sheet = try MeshPrimitives.grid(3.0, 1)
defer sheet.release()
let veiled = try MaterialAssignment.faces(sheet, "", "material", "materials/veil")
defer veiled.release()
let veil = try (try GeometrySet.of_mesh(veiled)).value().transformed(Vector3(0.0, 0.5, 0.0), Vector3(), Vector3(1.0, 1.0, 1.0))
defer veil.release()
let both = try (try GeometrySet.of_mesh(floor)).value().merged(veil)
defer both.release()
var means: f64[2] = [0.0, 0.0]
for at in 0..<(usize)2:
let opacity = 0.5 if at == 0 else 0.0
let library = try both.value().with_material("materials/veil", "openpbr", "geometry_opacity\nbase_weight\nspecular_weight", [opacity, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
defer library.release()
# Seen from below the veil, looking at the floor under the light.
let pitch = -math.atan2(0.3, 3.0)
let viewed = try library.value().with_camera("/camera", Vector3(0.0, 0.3, 3.0), Vector3(pitch, 0.0, 0.0), 0, 200.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer viewed.release()
let set = try viewed.value().with_light("/key", Vector3(0.0, 1.0, 0.0), Vector3(-0.5 * math.pi, 0.0, 0.0), 0, Vector3(1.0, 1.0, 1.0), 4.0, 0.0, 0.0, false, 1.0, 1.0, 0.5, 0.0, false)
defer set.release()
var settings = render.RenderSettings.of(32, 32, 256)
settings.spectral = false
settings.max_bounces = 1
settings.material.base_color = Vector3(0.5, 0.5, 0.5)
settings.material.specular_weight = 0.0
let pixels = try new f32[32 * 32 * 4] --- in memory.heap
defer free(pixels) in memory.heap
try rendered(device, set.value(), settings, pixels)
means[at] = window_mean(pixels, 32, 14, 14, 4).y
if math.abs(means[0] / means[1] - 0.5) > 0.015:
print(f"cut-out shadow: {means[0]} at opacity 0.5 against {means[1]} at 0")
assert(false)
## A sphere under an area light, half the frame empty sky: with adaptive
## sampling the image is the same (it only stops sampling where it is clean)
## and the empty sky stops early.
func adaptive(device: gpu.Device) -> !:
let sphere = try MeshPrimitives.sphere(1.0, 32)
defer sphere.release()
let base = try GeometrySet.of_mesh(sphere)
defer base.release()
let viewed = try base.value().with_camera("/camera", Vector3(1.5, 1.0, 5.0), Vector3(), 0, 35.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer viewed.release()
let set = try viewed.value().with_light("/key", Vector3(1.0, 4.0, 1.0), Vector3(-1.2, 0.3, 0.0), 0, Vector3(1.0, 1.0, 1.0), 20.0, 0.0, 0.0, true, 2.0, 2.0, 0.5, 0.0, false)
defer set.release()
var scene = try render.compile_scene(set.value())
defer scene.close()
var sums: f64[2] = [0.0, 0.0]
var stopped: usize = 0
let pixels = try new f32[64 * 48 * 4] --- in memory.heap
defer free(pixels) in memory.heap
for at in 0..<(usize)2:
var settings = render.RenderSettings.of(64, 48, 64)
settings.spectral = false
settings.noise_threshold = 0.01 if at == 0 else 0.0
var renderer = try render.Renderer.create(device, &scene, settings)
defer renderer.destroy()
try renderer.finish()
try renderer.read(pixels)
for p in 0..<(usize)(64 * 48): sums[at] += (f64)pixels[p * 4 + 1]
if at == 0: stopped = try renderer.converged_pixels()
if math.abs(sums[0] / sums[1] - 1.0) > 0.01 or stopped < 64 * 48 // 3:
print(f"adaptive: image sums {sums[0]} against {sums[1]}, {stopped} of {64 * 48} pixels stopped")
assert(false)
## A closed 6 × 3 × 6 room lit only by a lamp in a narrow shade that throws a
## small bright spot on the ceiling: everything the camera sees is lit by that
## spot's bounce, which cosine sampling rarely finds and light sampling cannot.
## Path guiding learns where it is; at equal samples (four seeds, each shared
## by both ways) the image is closer to a long unguided reference.
## The room of guided_room (and lit_room).
func lamp_room() -> interop.Reference[GeometrySet]!:
let floor = try MeshPrimitives.grid(6.0, 4)
defer floor.release()
let wall = try MeshPrimitives.grid(6.0, 4)
defer wall.release()
let shade = try MeshPrimitives.grid(1.0, 1)
defer shade.release()
var room = try GeometrySet.of_mesh(floor)
let placements: Vector3[10] = [Vector3(0.0, 3.0, 0.0), Vector3(0.0, 0.0, 0.0),
Vector3(3.0, 1.5, 0.0), Vector3(0.0, 0.0, 0.5 * math.pi),
Vector3(-3.0, 1.5, 0.0), Vector3(0.0, 0.0, 0.5 * math.pi),
Vector3(0.0, 1.5, 3.0), Vector3(0.5 * math.pi, 0.0, 0.0),
Vector3(0.0, 1.5, -3.0), Vector3(0.5 * math.pi, 0.0, 0.0)]
for at in 0..<(usize)5:
let placed = try (try GeometrySet.of_mesh(wall)).value().transformed(placements[at * 2], placements[at * 2 + 1], Vector3(1.0, 1.0, 1.0))
room = try room.value().merged(placed)
# The shade: four 0.3-wide, 1-tall panels around the lamp.
let sides: Vector3[8] = [Vector3(0.15, 0.7, 0.0), Vector3(0.0, 0.0, 0.5 * math.pi), Vector3(-0.15, 0.7, 0.0), Vector3(0.0, 0.0, 0.5 * math.pi),
Vector3(0.0, 0.7, 0.15), Vector3(0.5 * math.pi, 0.0, 0.0), Vector3(0.0, 0.7, -0.15), Vector3(0.5 * math.pi, 0.0, 0.0)]
# The grid lies in XZ: the axis that turns vertical takes the height.
let scales: Vector3[4] = [Vector3(1.0, 1.0, 0.3), Vector3(1.0, 1.0, 0.3), Vector3(0.3, 1.0, 1.0), Vector3(0.3, 1.0, 1.0)]
for at in 0..<(usize)4:
let panel = try (try GeometrySet.of_mesh(shade)).value().transformed(sides[at * 2], sides[at * 2 + 1], scales[at])
room = try room.value().merged(panel)
let viewed = try room.value().with_camera("/camera", Vector3(2.5, 1.5, 2.5), Vector3(-0.15, 0.785, 0.0), 0, 24.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer viewed.release()
return try viewed.value().with_light("/lamp", Vector3(0.0, 0.25, 0.0), Vector3(0.5 * math.pi, 0.0, 0.0), 0, Vector3(1.0, 1.0, 1.0), 200.0, 0.0, 0.0, false, 0.2, 0.2, 0.5, 0.0, false)
func guided_room(device: gpu.Device) -> !:
let set = try lamp_room()
defer set.release()
var scene = try render.compile_scene(set.value())
defer scene.close()
let size: usize = 256 * 192 * 4
let images = try new f32[size * 3] --- in memory.heap
defer free(images) in memory.heap
var errors: f64[2] = [0.0, 0.0]
for round in 0..<(usize)5:
for way in 0..<(usize)2:
if round == 0 and way == 1: continue
var settings = render.RenderSettings.of(256, 192, 4096 if round == 0 else 256)
settings.spectral = false
settings.max_bounces = 2
settings.material.base_color = Vector3(0.3, 0.3, 0.3)
settings.material.specular_weight = 0.0
settings.guiding = round > 0 and way == 1
settings.light_tracing = 0.0
settings.seed = (u32)(round + 1)
var renderer = try render.Renderer.create(device, &scene, settings)
defer renderer.destroy()
try renderer.finish()
let slot = 0 if round == 0 else 1 + way
try renderer.read(images[slot * size..<(slot + 1) * size])
if round == 0: continue
for p in 0..<(usize)(256 * 192):
let reference = (f64)images[p * 4 + 1]
for k in 0..<(usize)2:
let d = (f64)images[(k + 1) * size + p * 4 + 1] - reference
errors[k] += d * d
print(f"guiding: room MSE at 256 samples {errors[1]} guided against {errors[0]} unguided ({errors[0] / math.max(errors[1], 1e-30)}x better)")
assert(errors[1] < errors[0])
## Light tracing in the lamp room: everything seen is lit by the small bright
## spot the shaded lamp throws on the ceiling. Light paths reach it easily, so
## with them the image at equal samples is closer to a long reference, and its
## mean agrees with it (MIS weights that sum to one).
func lit_room(device: gpu.Device) -> !:
let set = try lamp_room()
defer set.release()
var scene = try render.compile_scene(set.value())
defer scene.close()
let size: usize = 128 * 96 * 4
let images = try new f32[size * 3] --- in memory.heap
defer free(images) in memory.heap
for way in 0..<(usize)3:
var settings = render.RenderSettings.of(128, 96, 4096 if way == 0 else 256)
settings.spectral = false
settings.max_bounces = 3
settings.material.base_color = Vector3(0.5, 0.5, 0.5)
settings.material.specular_weight = 0.0
settings.light_tracing = 1.0 if way == 2 else 0.0
settings.seed = (u32)(way + 1)
var renderer = try render.Renderer.create(device, &scene, settings)
defer renderer.destroy()
try renderer.finish()
try renderer.read(images[way * size..<(way + 1) * size])
var errors: f64[2] = [0.0, 0.0]
var means: f64[3] = [0.0, 0.0, 0.0]
for p in 0..<(usize)(128 * 96):
let reference = (f64)images[p * 4 + 1]
means[0] += reference
for k in 0..<(usize)2:
let value = (f64)images[(k + 1) * size + p * 4 + 1]
means[k + 1] += value
errors[k] += (value - reference) * (value - reference)
print(f"light tracing: room MSE at 256 samples {errors[1]} against {errors[0]} without ({errors[0] / math.max(errors[1], 1e-30)}x better); mean {means[2] / means[0]} of the reference's")
assert(errors[1] < errors[0])
assert(math.abs(means[2] / means[0] - 1.0) < 0.01)
## Through a thin lens (f/0.5 on a 50 mm lens, focused 2 m away, past the
## sphere), light paths that land on the lens and camera paths that leave it
## agree on the image's mean.
func thin_lens(device: gpu.Device) -> !:
let ball = try MeshPrimitives.sphere(0.5, 32)
defer ball.release()
let floor = try MeshPrimitives.grid(20.0, 8)
defer floor.release()
let both = try (try GeometrySet.of_mesh(ball)).value().merged(try GeometrySet.of_mesh(floor))
defer both.release()
let viewed = try both.value().with_camera("/camera", Vector3(0.0, 0.6, 3.0), Vector3(-0.1, 0.0, 0.0), 0, 50.0, 36.0, 24.0, 0.1, 100.0, 0.5, 2.0)
defer viewed.release()
let set = try viewed.value().with_light("/key", Vector3(0.0, 2.0, 0.0), Vector3(-0.5 * math.pi, 0.0, 0.0), 0, Vector3(1.0, 1.0, 1.0), 8.0, 0.0, 0.0, false, 1.0, 1.0, 0.5, 0.0, false)
defer set.release()
var means: f64[2] = [0.0, 0.0]
let pixels = try new f32[48 * 32 * 4] --- in memory.heap
defer free(pixels) in memory.heap
for way in 0..<(usize)2:
var settings = render.RenderSettings.of(48, 32, 2048)
settings.spectral = false
settings.max_bounces = 3
settings.light_tracing = 1.0 if way == 1 else 0.0
settings.seed = (u32)(way + 1)
try rendered(device, set.value(), settings, pixels)
for p in 0..<(usize)(48 * 32): means[way] += (f64)pixels[p * 4 + 1]
print(f"thin lens: light paths give {means[1] / means[0]} of the camera paths' mean")
assert(math.abs(means[1] / means[0] - 1.0) < 0.005)
## A white sphere under a white dome light with no image: the furnace again,
## lit by the dome's light samples and BSDF hits under MIS instead of the
## background.
func dome_furnace(device: gpu.Device, spectral: bool) -> !:
let sphere = try MeshPrimitives.sphere(1.0, 32)
defer sphere.release()
let base = try GeometrySet.of_mesh(sphere)
defer base.release()
let viewed = try base.value().with_camera("/camera", Vector3(0.0, 1.0, 4.0), Vector3(), 0, 50.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer viewed.release()
let set = try viewed.value().with_light("/sky", Vector3(), Vector3(0.3, 1.0, 0.0), 4, Vector3(1.0, 1.0, 1.0), 1.0, 0.0, 0.0, false, 1.0, 1.0, 0.5, 0.0, true)
defer set.release()
var settings = render.RenderSettings.of(64, 48, 64)
settings.spectral = spectral
settings.max_bounces = 64
settings.material.base_color = Vector3(1.0, 1.0, 1.0)
let pixels = try new f32[64 * 48 * 4] --- in memory.heap
defer free(pixels) in memory.heap
try rendered(device, set.value(), settings, pixels)
let mean = window_mean(pixels, 64, 0, 0, 48)
let center = window_mean(pixels, 64, 24, 16, 16)
if math.abs(mean.y - 1.0) > 0.01 or math.abs(center.y - 1.0) > 0.02 or math.abs(center.x - 1.0) > 0.03:
print(f"dome furnace (spectral {spectral}): mean {mean.x} {mean.y} {mean.z}, on the sphere {center.x} {center.y} {center.z}")
assert(false)
## The sky of dome_sun: a dim grey sky with a small sun 400 times brighter,
## 64 × 32 texels, as an OpenEXR file at `file`; returns the irradiance a floor
## facing +Y receives from it (the dome turned so its +Y is up).
func write_sky(file: str) -> f64!:
let width: usize = 64
let height: usize = 32
var raster = Raster(width = width, height = height)
defer raster.close()
try raster.channel("B", SampleType.float32)
try raster.channel("G", SampleType.float32)
try raster.channel("R", SampleType.float32)
try raster.allocate()
var irradiance: f64 = 0.0
for y in 0..<height:
for x in 0..<width:
let sun = x >= 40 and x < 42 and y >= 8 and y < 10
let value = 200.0 if sun else 0.5
for k in 0..<(usize)3: raster.pixels[(y * width + x) * 3 + k] = value
# ∫ cos θ dω over the texel, in 8 × 8 pieces (cos θ is +Y's).
for sy in 0..<(usize)8:
let theta = math.pi * ((f64)y + ((f64)sy + 0.5) / 8.0) / (f64)height
let cos_theta = math.cos(theta)
if cos_theta <= 0.0: continue
irradiance += value * cos_theta * math.sin(theta) * (math.pi / (f64)height / 8.0) * (2.0 * math.pi / (f64)width)
var encoded = Buffer()
defer:
if encoded.data.length > 0: free(encoded.data) in memory.heap
try exr.encode(&raster, &encoded, "none")
try files.write((c.str)file, encoded.data[..<encoded.used])
return irradiance
## A grey floor under a dome light whose image has a small bright sun: what
## the floor reflects straight up is albedo / π × the image's irradiance, which
## needs the image sampled by importance (the sun is 1/512 of the texels).
func dome_sun(device: gpu.Device, spectral: bool) -> !:
var file = Growing[u8]()
defer file.close()
try file.assign(path.temp().bytes)
for byte in "/luce-render-sky.exr".bytes: try file.push(byte)
try file.push(0)
let name = (str)file.items[..<file.count - 1]
let irradiance = try write_sky(name)
let floor = try MeshPrimitives.grid(20.0, 8)
defer floor.release()
let base = try GeometrySet.of_mesh(floor)
defer base.release()
let viewed = try base.value().with_camera("/camera", Vector3(0.0, 4.0, 0.0), Vector3(-0.5 * math.pi, 0.0, 0.0), 0, 50.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer viewed.release()
let set = try viewed.value().with_light("/sky", Vector3(), Vector3(), 4, Vector3(1.0, 1.0, 1.0), 1.0, 0.0, 0.0, false, 1.0, 1.0, 0.5, 0.0, false, name)
defer set.release()
var settings = render.RenderSettings.of(32, 32, 256)
settings.spectral = spectral
settings.max_bounces = 1
settings.material.base_color = Vector3(0.5, 0.5, 0.5)
settings.material.specular_weight = 0.0
let pixels = try new f32[32 * 32 * 4] --- in memory.heap
defer free(pixels) in memory.heap
try rendered(device, set.value(), settings, pixels)
let measured = window_mean(pixels, 32, 0, 0, 32)
let expected = 0.5 / math.pi * irradiance
print(f"dome sun (spectral {spectral}): {measured.x} {measured.y} {measured.z}, expected {expected}")
assert(math.abs(measured.y / expected - 1.0) < 0.02)
## The rect light over a floor whose grey comes from a texture through a node
## graph (an image node driving base_color): an sRGB PNG of 188s (0.502
## linear) mapped by the floor's texture coordinates lights as a material of
## that grey does.
func textured_floor(device: gpu.Device, spectral: bool) -> !:
var file = Growing[u8]()
defer file.close()
try file.assign(path.temp().bytes)
for byte in "/luce-render-grey.png".bytes: try file.push(byte)
try file.push(0)
let name = (str)file.items[..<file.count - 1]
var texels: u8[64]
for at in 0..<(usize)16:
texels[at * 4] = 188
texels[at * 4 + 1] = 188
texels[at * 4 + 2] = 188
texels[at * 4 + 3] = 255
var encoded = Buffer()
defer:
if encoded.data.length > 0: free(encoded.data) in memory.heap
try png.encode_rgba8(texels[0..<64], 4, 4, &encoded)
try files.write((c.str)name, encoded.data[..<encoded.used])
let grid = try MeshPrimitives.grid(20.0, 8)
defer grid.release()
let mapped = try AttributeKernels.uv_project(grid, 0.05)
defer mapped.release()
let bound = try MaterialAssignment.faces(mapped, "", "material", "materials/floor")
defer bound.release()
let base = try GeometrySet.of_mesh(bound)
defer base.release()
let albedo = math.pow((188.0 / 255.0 + 0.055) / 1.055, 2.4)
var means: f64[2] = [0.0, 0.0]
for way in 0..<(usize)2:
var graph = Growing[u8]()
defer graph.close()
try append_text(&graph, "\nnode grey image ")
try append_text(&graph, name)
try append_text(&graph, "; node surface openpbr_surface; link surface base_color grey color")
let library = try (try base.value().with_material("materials/floor", "openpbr", "specular_weight\nshader_graph", [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], (str)graph.view()) if way == 0
else try base.value().with_material("materials/floor", "openpbr", "base_color\nspecular_weight", [albedo, albedo, albedo, 0.0, 0.0, 0.0, 0.0, 0.0]))
defer library.release()
means[way] = try floor_window(device, library, spectral)
print(f"textured floor (spectral {spectral}): {means[0]} against a grey material's {means[1]}")
assert(math.abs(means[0] / means[1] - 1.0) < 0.005)
## Every kind of node in one graph, wired so the floor comes out a 0.5 grey
## with its flat normal: noise into a ramp of one grey, a checker of one grey
## choosing between that and (multiply, map range, clamp) combined, split and
## combined again, and a normal map of the flat color. It must light as a 0.5
## grey material does.
func graph_nodes(device: gpu.Device, spectral: bool) -> !:
let grid = try MeshPrimitives.grid(20.0, 8)
defer grid.release()
let mapped = try AttributeKernels.uv_project(grid, 0.05)
defer mapped.release()
let bound = try MaterialAssignment.faces(mapped, "", "material", "materials/floor")
defer bound.release()
let base = try GeometrySet.of_mesh(bound)
defer base.release()
let graph = "\nnode n noise; input n scale 3; node r ramp; link r fac n fac; input r color1 0.5; input r color2 0.5; node c checker; input c color1 0.5; input c color2 0.5; node a math multiply; input a a 0.25; input a b 2; node b map_range; input b value 0.25; input b from_max 0.5; node d clamp; input d value 0.7; input d max 0.5; node k combine; link k r a value; link k g b value; link k b d value; node m mix; link m fac c fac; link m a r color; link m b k color; node s separate; link s color m color; node x combine; link x r s r; link x g s g; link x b s b; node nm normal_map; node surface openpbr_surface; link surface base_color x color; link surface geometry_normal nm normal"
var means: f64[2] = [0.0, 0.0]
for way in 0..<(usize)2:
let library = try (try base.value().with_material("materials/floor", "openpbr", "specular_weight\nshader_graph", [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], graph) if way == 0
else try base.value().with_material("materials/floor", "openpbr", "base_color\nspecular_weight", [0.5, 0.5, 0.5, 0.0, 0.0, 0.0, 0.0, 0.0]))
defer library.release()
means[way] = try floor_window(device, library, spectral)
print(f"graph nodes (spectral {spectral}): {means[0]} against a grey material's {means[1]}")
assert(math.abs(means[0] / means[1] - 1.0) < 0.005)
## A bump of a height rising 0.5 a unit along x, by position and by texture
## coordinates (u is 0.05 x), must tilt the floor's normal to (-0.5, 1, 0)
## normalized: it must light as that normal given outright does.
func bump_slope(device: gpu.Device) -> !:
let grid = try MeshPrimitives.grid(20.0, 8)
defer grid.release()
let mapped = try AttributeKernels.uv_project(grid, 0.05)
defer mapped.release()
let bound = try MaterialAssignment.faces(mapped, "", "material", "materials/floor")
defer bound.release()
let base = try GeometrySet.of_mesh(bound)
defer base.release()
let tilted = "\nnode c color; input c color -0.4472136 0.8944272 0; node surface openpbr_surface; link surface geometry_normal c color"
let by_position = "\nnode p position; node s separate; link s color p position; node h math multiply; link h a s r; input h b 0.5; node b bump; link b height h value; node surface openpbr_surface; link surface geometry_normal b normal"
let by_uv = "\nnode u uv; node s separate; link s color u uv; node h math multiply; link h a s r; input h b 10; node b bump; link b height h value; node surface openpbr_surface; link surface geometry_normal b normal"
let flat = "\nnode b bump; input b height 0.3; node surface openpbr_surface; link surface geometry_normal b normal"
var means: f64[4] = [0.0, 0.0, 0.0, 0.0]
let graphs: str[4] = [tilted, by_position, by_uv, flat]
for way in 0..<(usize)4:
let library = try base.value().with_material("materials/floor", "openpbr", "specular_weight\nshader_graph", [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], graphs[way])
defer library.release()
means[way] = try floor_window(device, library, false)
print(f"bump slope: tilted {means[0]}, by position {means[1]}, by uv {means[2]}, flat {means[3]}")
assert(math.abs(means[1] / means[0] - 1.0) < 0.005 and math.abs(means[2] / means[0] - 1.0) < 0.005)
# A constant height leaves the normal alone, which lights differently.
assert(math.abs(means[3] / means[0] - 1.0) > 0.02)
## A material whose graph reads the view (Layer Weight's facing picks its
## color, Fresnel its roughness) on a sphere and the floor: light paths connect
## at such surfaces but cannot scatter on from them, and camera paths count no
## light-path density through them; the image's mean must not change.
func viewed_graph(device: gpu.Device, spectral: bool) -> !:
let material = "materials/viewed"
let ball = try MeshPrimitives.sphere(0.5, 32)
defer ball.release()
let bound_ball = try MaterialAssignment.faces(ball, "", "material", material)
defer bound_ball.release()
let floor = try MeshPrimitives.grid(20.0, 8)
defer floor.release()
let bound_floor = try MaterialAssignment.faces(floor, "", "material", material)
defer bound_floor.release()
let both = try (try GeometrySet.of_mesh(bound_ball)).value().merged(try GeometrySet.of_mesh(bound_floor))
defer both.release()
let graph = "\nnode w layer_weight; input w blend 0.3; node m mix; link m fac w facing; input m a 0.8 0.7 0.6; input m b 0.1 0.2 0.4; node f fresnel; input f ior 1.45; node r map_range; link r value f fac; input r to_min 0.6; input r to_max 0.05; node surface openpbr_surface; link surface base_color m color; link surface specular_roughness r value"
let library = try both.value().with_material(material, "openpbr", "specular_weight\nshader_graph", [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], graph)
defer library.release()
let viewed = try library.value().with_camera("/camera", Vector3(0.0, 0.6, 3.0), Vector3(-0.1, 0.0, 0.0), 0, 50.0, 36.0, 24.0, 0.1, 100.0, 0.0, 2.0)
defer viewed.release()
let set = try viewed.value().with_light("/key", Vector3(0.0, 2.0, 0.0), Vector3(-0.5 * math.pi, 0.0, 0.0), 0, Vector3(1.0, 1.0, 1.0), 8.0, 0.0, 0.0, false, 1.0, 1.0, 0.5, 0.0, false)
defer set.release()
var means: f64[2] = [0.0, 0.0]
let pixels = try new f32[48 * 32 * 4] --- in memory.heap
defer free(pixels) in memory.heap
for way in 0..<(usize)2:
var settings = render.RenderSettings.of(48, 32, 2048)
settings.spectral = spectral
settings.max_bounces = 3
settings.light_tracing = 1.0 if way == 1 else 0.0
settings.seed = (u32)(way + 1)
try rendered(device, set.value(), settings, pixels)
for p in 0..<(usize)(48 * 32): means[way] += (f64)pixels[p * 4 + 1]
print(f"viewed graph (spectral {spectral}): light paths give {means[1] / means[0]} of the camera paths' mean")
assert(math.abs(means[1] / means[0] - 1.0) < 0.005)
## The mean of the window below the rect light, lit by it, of `library` (a floor).
func floor_window(device: gpu.Device, library: interop.Reference[GeometrySet], spectral: bool) -> f64!:
let pitch = -math.atan2(0.5, 3.0)
let viewed = try library.value().with_camera("/camera", Vector3(0.0, 0.5, 3.0), Vector3(pitch, 0.0, 0.0), 0, 200.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer viewed.release()
let set = try viewed.value().with_light("/key", Vector3(0.0, 1.0, 0.0), Vector3(-0.5 * math.pi, 0.0, 0.0), 0, Vector3(1.0, 1.0, 1.0), 4.0, 0.0, 0.0, false, 1.0, 1.0, 0.5, 0.0, false)
defer set.release()
var settings = render.RenderSettings.of(32, 32, 1024)
settings.spectral = spectral
settings.max_bounces = 1
settings.light_tracing = 0.0
let pixels = try new f32[32 * 32 * 4] --- in memory.heap
defer free(pixels) in memory.heap
try rendered(device, set.value(), settings, pixels)
return window_mean(pixels, 32, 14, 14, 4).y
func area_light(device: gpu.Device, spectral: bool, light_tracing: f64) -> !:
let floor = try MeshPrimitives.grid(20.0, 8)
defer floor.release()
let base = try GeometrySet.of_mesh(floor)
defer base.release()
# Seen from the side, so the light stays out of the picture: the image
# center looks at the floor straight below the light.
let pitch = -math.atan2(0.5, 3.0)
let viewed = try base.value().with_camera("/camera", Vector3(0.0, 0.5, 3.0), Vector3(pitch, 0.0, 0.0), 0, 200.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer viewed.release()
let set = try viewed.value().with_light("/key", Vector3(0.0, 1.0, 0.0), Vector3(-0.5 * math.pi, 0.0, 0.0), 0, Vector3(1.0, 1.0, 1.0), 4.0, 0.0, 0.0, false, 1.0, 1.0, 0.5, 0.0, false)
defer set.release()
# Light paths land on the measured pixels a few a sample: they need more.
var settings = render.RenderSettings.of(32, 32, 256 if light_tracing == 0.0 else 4096)
settings.spectral = spectral
settings.max_bounces = 1
settings.light_tracing = light_tracing
settings.material.base_color = Vector3(0.5, 0.5, 0.5)
settings.material.specular_weight = 0.0
let pixels = try new f32[32 * 32 * 4] --- in memory.heap
defer free(pixels) in memory.heap
try rendered(device, set.value(), settings, pixels)
let measured = window_mean(pixels, 32, 14, 14, 4)
let expected = 0.5 / math.pi * 4.0 * 4.0 * corner_irradiance(0.5, 0.5, 1.0)
if math.abs(measured.y / expected - 1.0) > 0.02 or math.abs(measured.x / expected - 1.0) > 0.03:
print(f"area light (spectral {spectral}, light paths {light_tracing}): {measured.x} {measured.y} {measured.z}, expected {expected}")
assert(false)
## A colored light, or a white one at a color temperature: products of two
## spectra are not products of their RGBs, so the two are checked apart.
func spectral_agrees(device: gpu.Device, kelvin: f64) -> !:
let color = Vector3(1.0, 0.4, 0.1) if kelvin == 0.0 else Vector3(1.0, 1.0, 1.0)
let floor = try MeshPrimitives.grid(20.0, 8)
defer floor.release()
let base = try GeometrySet.of_mesh(floor)
defer base.release()
let pitch = -math.atan2(2.0, 4.0)
let viewed = try base.value().with_camera("/camera", Vector3(0.0, 2.0, 4.0), Vector3(pitch, 0.0, 0.0), 0, 35.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer viewed.release()
let set = try viewed.value().with_light("/key", Vector3(0.0, 2.0, 0.0), Vector3(-0.5 * math.pi, 0.0, 0.0), 0, color, 10.0, 0.0, kelvin, true, 2.0, 2.0, 0.5, 0.0, false)
defer set.release()
let pixels = try new f32[48 * 32 * 4] --- in memory.heap
defer free(pixels) in memory.heap
var means: Vector3[2] = [Vector3(), Vector3()]
for build in 0..<(usize)2:
var settings = render.RenderSettings.of(48, 32, 64)
settings.spectral = build == 0
settings.max_bounces = 4
settings.material.base_color = Vector3(0.9, 0.9, 0.9)
try rendered(device, set.value(), settings, pixels)
means[build] = window_mean(pixels, 48, 8, 0, 32)
let s = means[0]
let r = means[1]
if math.abs(s.x / r.x - 1.0) > 0.03 or math.abs(s.y / r.y - 1.0) > 0.03 or math.abs(s.z / r.z - 1.0) > 0.06:
print(f"spectral against RGB ({kelvin} K): {s.x} {s.y} {s.z} against {r.x} {r.y} {r.z}")
assert(false)
## Hardware ray queries and the software BVH render the same image: the same
## samples meet the same triangles, so pixels differ only by float rounding.
func hardware_agrees(device: gpu.Device) -> !:
if not (try device.limits()).ray_query:
print("skip: no ray queries on this device")
return
let floor = try MeshPrimitives.grid(20.0, 8)
defer floor.release()
let sphere = try MeshPrimitives.sphere(1.0, 32)
defer sphere.release()
let both = try (try GeometrySet.of_mesh(floor)).value().merged(try GeometrySet.of_mesh(sphere))
defer both.release()
let viewed = try both.value().with_camera("/camera", Vector3(0.0, 1.5, 5.0), Vector3(-0.2, 0.0, 0.0), 0, 35.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer viewed.release()
let set = try viewed.value().with_light("/key", Vector3(1.0, 4.0, 1.0), Vector3(-1.2, 0.3, 0.0), 0, Vector3(1.0, 1.0, 1.0), 20.0, 0.0, 0.0, true, 2.0, 2.0, 0.5, 0.0, false)
defer set.release()
let pixels = try new f32[64 * 48 * 4 * 2] --- in memory.heap
defer free(pixels) in memory.heap
for build in 0..<(usize)2:
var settings = render.RenderSettings.of(64, 48, 32)
settings.software_bvh = build == 1
# Guiding's statistics gather by float atomics in any order, so it
# would make the two runs choose differently; this compares tracing.
settings.guiding = false
try rendered(device, set.value(), settings, pixels[build * 64 * 48 * 4..<(build + 1) * 64 * 48 * 4])
var hardware = Vector3()
var software = Vector3()
var differ: usize = 0
for at in 0..<(usize)(64 * 48):
let a = Vector3((f64)pixels[at * 4], (f64)pixels[at * 4 + 1], (f64)pixels[at * 4 + 2])
let b = Vector3((f64)pixels[64 * 48 * 4 + at * 4], (f64)pixels[64 * 48 * 4 + at * 4 + 1], (f64)pixels[64 * 48 * 4 + at * 4 + 2])
hardware = hardware.add(a)
software = software.add(b)
if a.subtract(b).length() > 0.05 * math.max(0.1, b.length()): differ += 1
# A few pixels may take another branch where a ray grazes an edge.
if differ > 30 or math.abs(hardware.y / software.y - 1.0) > 0.005:
print(f"hardware against software: {differ} pixels differ; sums {hardware.y} and {software.y}")
assert(false)
## A 1920 × 1080 image of a sphere on a floor under an area light, 16 samples:
## printed, not checked.
func timing(device: gpu.Device) -> !:
let sphere = try MeshPrimitives.sphere(1.0, 64)
defer sphere.release()
let floor = try MeshPrimitives.grid(20.0, 64)
defer floor.release()
let ball = try GeometrySet.of_mesh(sphere)
defer ball.release()
let ground = try (try GeometrySet.of_mesh(floor)).value().transformed(Vector3(0.0, -1.0, 0.0), Vector3(), Vector3(1.0, 1.0, 1.0))
defer ground.release()
let both = try ball.value().merged(ground)
defer both.release()
let viewed = try both.value().with_camera("/camera", Vector3(0.0, 1.0, 5.0), Vector3(-0.2, 0.0, 0.0), 0, 35.0, 36.0, 24.0, 0.1, 100.0, 0.0, 4.0)
defer viewed.release()
let set = try viewed.value().with_light("/key", Vector3(2.0, 4.0, 2.0), Vector3(-1.0, 0.6, 0.0), 0, Vector3(1.0, 1.0, 1.0), 20.0, 0.0, 0.0, true, 2.0, 2.0, 0.5, 0.0, false)
defer set.release()
var scene = try render.compile_scene(set.value())
defer scene.close()
for build in 0..<(usize)3:
var settings = render.RenderSettings.of(1920, 1080, 16)
settings.spectral = build != 1
settings.software_bvh = build == 2
settings.background = Vector3(0.1, 0.1, 0.1)
var renderer = try render.Renderer.create(device, &scene, settings)
defer renderer.destroy()
let start = clock.now()
try renderer.finish()
let seconds = start.elapsed().seconds()
if build == 0:
# Where the time goes, from a profiled run of the same image.
var profiled_settings = settings
profiled_settings.profile = true
var profiled = try render.Renderer.create(device, &scene, profiled_settings)
defer profiled.destroy()
try profiled.finish()
var times: f64[10]
try profiled.kernel_times(times)
for at in 0..<(usize)10:
if times[at] > 0.0: print(f" {render.kernel_names[at]}: {times[at] / 16.0} ms a sample")
print(f"timing ({"RGB" if build == 1 else "spectral"}, {"ray queries" if renderer.ray_traced() else "software BVH"}): 1920x1080, {scene.triangle_count()} triangles, 16 samples, 12 bounces: {seconds * 1000.0 / 16.0} ms a sample")