Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-render

Source of release 0.1.3

0.1.3 / tests / gpu / interactive.lucb

## Interactive renders, as a viewport makes them: a view placed by the caller
## (look_frame), restarted through other views and sizes, and a scene
## reloaded with other lights while its geometry stays on the device. Each is
## checked against a renderer made afresh for the same view and scene: the
## sample sequence starts over, so the images agree but for the order of the
## light paths' atomic splats.
import memory
from luce_std import math
from luce_gpu import gpu
from luce_render import render
from luce_geocore.geocore import Vector3, MeshPrimitives, GeometrySet
import interop

pub func checks(device: gpu.Device) -> !:
    let ball = try MeshPrimitives.sphere(0.6, 24)
    defer ball.release()
    let sphere = try (try GeometrySet.of_mesh(ball)).value().transformed(Vector3(0.0, 0.0, 0.0), Vector3(), Vector3(1.0, 1.0, 1.0))
    defer sphere.release()
    let floor = try MeshPrimitives.grid(10.0, 4)
    defer floor.release()
    let ground = try GeometrySet.of_mesh(floor)
    defer ground.release()
    let both = try sphere.value().merged(ground)
    defer both.release()
    let lit = try with_key(both, 6.0)
    defer lit.release()
    let brighter = try with_key(both, 12.0)
    defer brighter.release()
    # The geometry is the same arrays however the lights change; other
    # geometry, or the same placed elsewhere, is not.
    assert(try render.same_geometry(lit.value(), brighter.value()))
    assert(not (try render.same_geometry(lit.value(), ground.value())))
    let moved = try lit.value().transformed(Vector3(0.0, 0.1, 0.0), Vector3(), Vector3(1.0, 1.0, 1.0))
    defer moved.release()
    assert(not (try render.same_geometry(lit.value(), moved.value())))

    let a = try view(Vector3(0.0, 1.5, 4.0), 48, 32)
    let b = try view(Vector3(3.0, 2.5, 1.0), 48, 32)
    let half = try view(Vector3(0.0, 1.5, 4.0), 24, 16)
    var settings = render.RenderSettings.of(48, 32, 24)
    settings.max_bounces = 4
    settings.material.base_color = Vector3(0.6, 0.6, 0.6)
    let size: usize = 48 * 32 * 4
    let fresh = try new f32[size] --- in memory.heap
    defer free(fresh) in memory.heap
    let again = try new f32[size] --- in memory.heap
    defer free(again) in memory.heap

    # Through A afresh; then a renderer through B restarted through A.
    try rendered(device, lit.value(), settings, a, fresh)
    var scene = try render.compile_scene(lit.value())
    defer scene.close()
    var renderer = try render.Renderer.create_viewed(device, &scene, settings, b)
    defer renderer.destroy()
    try renderer.finish()
    assert(renderer.samples_done() == 24)
    try renderer.restart(a)
    assert(renderer.samples_done() == 0)
    try renderer.finish()
    try renderer.read(again)
    try agree("restarted through another view", fresh, again)

    # A smaller view fills the images' corner; growing back makes them again.
    try renderer.restart(half)
    try renderer.finish()
    let shown = renderer.shown_size()
    assert(shown[0] == 24 and shown[1] == 16)
    try renderer.restart(a)
    try renderer.finish()
    try renderer.read(again)
    try agree("back from a smaller view", fresh, again)

    # Restarted mid-render: passes in flight count for nothing.
    try renderer.restart(b)
    _ = try renderer.advance()
    _ = try renderer.advance()
    try renderer.restart(a)
    try renderer.finish()
    try renderer.read(again)
    try agree("restarted with passes in flight", fresh, again)

    # A light twice as bright, reloaded over the same geometry, against a
    # renderer made for it; and about twice the light.
    var reloaded = try render.compile_scene(brighter.value(), false)
    defer reloaded.close()
    assert(reloaded.splats.count() == 0 and reloaded.nodes.count == 0 and reloaded.triangle_count() == scene.triangle_count())
    try renderer.reload(&reloaded, settings)
    try renderer.finish()
    try renderer.read(again)
    try rendered(device, brighter.value(), settings, a, fresh)
    try agree("reloaded with a brighter light", fresh, again)
    let before = try new f32[size] --- in memory.heap
    defer free(before) in memory.heap
    try rendered(device, lit.value(), settings, a, before)
    let ratio = mean(again) / mean(before)
    if math.abs(ratio - 2.0) > 0.02:
        print(f"a light twice as bright gives {ratio} times the light")
        assert(false)
    print("PASS interactive: restarts through other views and sizes, with passes in flight, and reloads with other lights agree with fresh renders")

func with_key(set: interop.Reference[GeometrySet], intensity: f64) -> interop.Reference[GeometrySet]!:
    return try set.value().with_light("/key", Vector3(0.0, 3.0, 0.0), Vector3(-0.5 * math.pi, 0.0, 0.0), 0, Vector3(1.0, 1.0, 1.0), intensity, 0.0, 0.0, false, 2.0, 2.0, 0.5, 0.0, false)

## A 40° view from `eye` at the sphere.
func view(eye: Vector3, width: u32, height: u32) -> render.RayFrame!:
    return try render.look_frame(eye, Vector3().subtract(eye), Vector3(0.0, 1.0, 0.0), math.tan(20.0 * math.pi / 180.0), width, height)

func rendered(device: gpu.Device, set: const GeometrySet*, settings: render.RenderSettings, frame: render.RayFrame, out: f32[]) -> !:
    var scene = try render.compile_scene(set)
    defer scene.close()
    var renderer = try render.Renderer.create_viewed(device, &scene, settings, frame)
    defer renderer.destroy()
    try renderer.finish()
    try renderer.read(out)

func mean(pixels: const f32[]) -> f64:
    var sum: f64 = 0.0
    for at in 0..<pixels.length:
        if at % 4 != 3: sum += (f64)pixels[at]
    return sum / (f64)(pixels.length // 4 * 3)

## The images agree: the mean difference within 0.1% of the mean, and no
## pixel off by more than 2% of the brightest (light paths' splats land in
## another order).
func agree(what: str, expected: const f32[], got: const f32[]) -> !:
    var difference: f64 = 0.0
    var worst: f64 = 0.0
    var peak: f64 = 0.0
    for at in 0..<expected.length:
        if at % 4 == 3: continue
        let d = math.abs((f64)expected[at] - (f64)got[at])
        difference += d
        worst = math.max(worst, d)
        peak = math.max(peak, (f64)expected[at])
    difference /= (f64)(expected.length // 4 * 3)
    if difference > 1e-3 * mean(expected) or worst > 0.02 * peak:
        print(f"{what}: mean difference {difference} (image mean {mean(expected)}), worst {worst} of {peak}")
        assert(false)