Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-render

Source of release 0.1.3

0.1.3 / src / render / session.lucb

#==============================================================================================
#
#   render/session - A progressive render an application shows
#
#   DESCRIPTION:
#       RenderSession is what a Luce application holds, for a render panel's image
#       through a scene camera (`start`) or a viewport's through a view it places
#       (`look`, then `start_view`).
#
#       Starting compiles the GeometrySet on a thread of its own, since a big scene
#       (a million splats) takes seconds; each `draw` into a view's target picks up a
#       finished compile, advances the render one pass (never waiting for the GPU) and
#       draws the latest image fitted into a rectangle. The renderer is made on the
#       first draw after a compile, on the device the view draws with. `draw` returns
#       whether more passes are coming, so the view can ask for another frame.
#
#       Nothing is done twice:
#       - a new view (`look`: an orbit, a resize) restarts the film; the scene stays
#         on the device;
#       - a new scene whose geometry is the renderer's (its meshes and clouds the
#         same components, placed the same: a light or a material changed) compiles
#         without splats or BVHs and reloads the lights, materials and kernels,
#         keeping the geometry, its BLAS and TLAS on the device;
#       - only other geometry compiles and uploads everything.
#
#==============================================================================================

## A scene compiling on a thread of its own: the set (held until the compile
## is collected, and only by the main thread: a reference belongs to its
## runtime thread), a storage of it sharing its arrays for the compile's
## thread, whether to compile its geometry, and the result.
struct Compiling:
    var set: interop.Reference[GeometrySet]
    var storage: GeometrySet*
    var geometry: bool
    var scene: CompiledScene
    var failed: bool
    var message: Growing[u8]
    var finished: @u32
    var thread: thread.Handle

func compile_entry(context: void*?):
    let job = (Compiling*)(context else return)
    job.scene = compile_scene(job.storage, job.geometry) catch failure:
        job.failed = true
        append_text(&job.message, failure.message) catch _: _ = 0
        recover CompiledScene()
    job.finished.store(1, .release)

pub struct RenderSession:
    var device: gpu.Device
    ## The compile in progress, and a scene started meanwhile (which replaces
    ## it once it finishes); then the compiled scene waiting for the next draw.
    var compiling: Compiling*?
    var queued: interop.Reference[GeometrySet]?
    var waiting: CompiledScene?
    ## Whether `waiting` is only what a reload needs (the geometry is the renderer's).
    var waiting_reloads: bool
    var waiting_set: interop.Reference[GeometrySet]?
    ## The set the renderer's geometry came from (scene.lucb's same_geometry
    ## tells a new set's apart).
    var geometry_set: interop.Reference[GeometrySet]?
    var settings: RenderSettings
    var renderer: Renderer?
    ## A view placed by `look` in place of a scene camera.
    var viewing: bool
    var framing: RayFrame
    ## The scene camera of `start` ("" the first).
    var camera_path: Growing[u8]
    var started: clock.Instant
    ## Seconds the render took, once it has finished (0 while it runs).
    var took: f64
    var exposure_stops: f64
    var view: i64
    var problem_text: Growing[u8]
    ## The material the next `start` gives faces with none assigned, and its limits.
    var material: OpenPbr
    var diffuse: u32
    var glossy: u32
    var transmission: u32
    var clamp_indirect: f64
    var noise_threshold: f64
    var guiding: bool
    var light_tracing: f64
    ## Paths a pass traces (0: the renderer's choice); radiance where no
    ## surface is (linear ACEScg).
    var pool: u32
    var background: Vector3
    ## Compiles and uploads the session has made, for tests and benchmarks.
    var compiles: i64
    var uploads: i64
    var reloads: i64

    pub func init():
        self.device = gpu.Device()
        self.compiling = none
        self.queued = none
        self.waiting = none
        self.waiting_reloads = false
        self.waiting_set = none
        self.geometry_set = none
        self.settings = RenderSettings.of(1, 1, 1)
        self.renderer = none
        self.viewing = false
        self.framing = RayFrame(Vector3(), Vector3(), Vector3(), Vector3(), Vector3(0.0, 0.0, -1.0), false, 0, 0, 0.0, 1.0)
        self.camera_path = Growing[u8]()
        self.started = clock.now()
        self.took = 0.0
        self.exposure_stops = 0.0
        self.view = 1
        self.problem_text = Growing[u8]()
        self.material = OpenPbr.standard()
        self.diffuse = 1024
        self.glossy = 1024
        self.transmission = 1024
        self.clamp_indirect = 0.0
        self.noise_threshold = 0.0
        self.guiding = false
        self.light_tracing = RenderSettings.of(1, 1, 1).light_tracing
        self.pool = 0
        self.background = Vector3()
        self.compiles = 0
        self.uploads = 0
        self.reloads = 0

    pub static func make() -> interop.Reference[RenderSession]!:
        return try interop.Reference[RenderSession].adopt(try new RenderSession() in memory.heap, render_session_type, memory.heap)

    ## Render `set` through the camera at path `camera` ("" the first camera):
    ## `width` × `height` pixels, `samples` a pixel, at most `bounces`, spectral or RGB.
    ## Replaces any render in progress.
    pub func start(set: interop.Reference[GeometrySet], camera: str, width: i64, height: i64, samples: i64, bounces: i64, spectral: bool) -> !:
        if width < 1 or height < 1 or width > 16384 or height > 16384: error(invalid, "an image is 1 to 16384 pixels on a side")
        try self.prepare(samples, bounces, spectral)
        self.settings.width = (u32)width
        self.settings.height = (u32)height
        self.viewing = false
        self.camera_path.clear()
        try append_text(&self.camera_path, camera)
        try self.begin(set)

    ## Render `set` through the view `look` placed, `samples` a pixel at most,
    ## at most `bounces`, spectral or RGB: a viewport's render. Its cameras are
    ## not used. Replaces any render in progress; while its geometry is the
    ## renderer's, only lights, materials and settings load again.
    pub func start_view(set: interop.Reference[GeometrySet], samples: i64, bounces: i64, spectral: bool) -> !:
        if self.framing.width == 0: error(invalid, "a view render needs a view: call look first")
        try self.prepare(samples, bounces, spectral)
        self.settings.width = self.framing.width
        self.settings.height = self.framing.height
        self.viewing = true
        try self.begin(set)

    ## Place the view (a viewport's camera): at `position`, looking along
    ## `forward`, `up` toward the image's top, `tan_half_height` the tangent of
    ## half the vertical field of view, `width` × `height` pixels; an
    ## `orthographic` view is `2 · tan_half_height` scene units tall instead,
    ## its rays parallel. A render in progress starts over through it without
    ## loading anything again.
    pub func look(position: Vector3, forward: Vector3, up: Vector3, tan_half_height: f64, width: i64, height: i64, orthographic: bool = false) -> !:
        if width < 1 or height < 1 or width > 16384 or height > 16384: error(invalid, "an image is 1 to 16384 pixels on a side")
        self.framing = try look_frame(position, forward, up, tan_half_height, (u32)width, (u32)height, orthographic)
        self.viewing = true
        self.settings.width = (u32)width
        self.settings.height = (u32)height
        # A reload on its way (a light or a material changed) starts through
        # this view: the scene it replaces is not restarted for nothing.
        if self.reload_pending(): return
        if let running = self.renderer:
            var renderer = running
            try renderer.restart(self.framing)
            self.renderer = renderer
        self.started = clock.now()
        self.took = 0.0

    ## Whether the scene compiling or waiting only reloads the renderer's.
    func reload_pending() -> bool:
        if self.renderer == none: return false
        if self.waiting != none: return self.waiting_reloads
        let job = self.compiling else return false
        return not job.geometry

    ## The default material of the next start (faces with none assigned):
    ## OpenPBR parameters by name, one per line, four numbers each, as a
    ## Material node writes them.
    pub func set_material(names: str, values: const f64[]) -> !:
        var library = Materials()
        defer library.close()
        try library.add("default", "openpbr", names, values, none)
        self.material = openpbr_of(&library, 0)

    ## Bounce limits by kind, the indirect clamp (0 off), adaptive sampling's
    ## noise threshold (0 off), path guiding and light paths a pixel (0 off) of
    ## the next start.
    pub func set_limits(diffuse: i64, glossy: i64, transmission: i64, clamp_indirect: f64, noise_threshold: f64, guiding: bool, light_tracing: f64):
        self.diffuse = (u32)math.max(0.0, (f64)diffuse)
        self.glossy = (u32)math.max(0.0, (f64)glossy)
        self.transmission = (u32)math.max(0.0, (f64)transmission)
        self.clamp_indirect = math.max(0.0, clamp_indirect)
        self.noise_threshold = math.max(0.0, noise_threshold)
        self.guiding = guiding
        self.light_tracing = math.max(0.0, light_tracing)

    ## Take up to `samples` a pixel: a render that has finished goes on, one
    ## past it stops.
    pub func set_samples(samples: i64) -> !:
        if samples < 1: error(invalid, "a render needs samples")
        self.settings.samples = (u32)samples
        if let running = self.renderer:
            var renderer = running
            try renderer.set_samples((u32)samples)
            self.renderer = renderer
        if self.took > 0.0 and self.samples_done() < samples:
            self.took = 0.0

    ## Paths a pass traces from the next start (0: the renderer's choice):
    ## fewer keeps each pass short where a path costs much (splats).
    pub func set_pool(paths: i64):
        self.pool = (u32)math.max(0.0, (f64)paths)

    ## Radiance from wherever no surface is, from the next start (linear ACEScg).
    pub func set_background(red: f64, green: f64, blue: f64):
        self.background = Vector3(red, green, blue)

    func prepare(samples: i64, bounces: i64, spectral: bool) -> !:
        if samples < 1 or bounces < 1 or bounces > 1024: error(invalid, "a render needs samples and 1 to 1024 bounces")
        self.problem_text.clear()
        var settings = RenderSettings.of(1, 1, (u32)samples)
        settings.max_bounces = (u32)bounces
        settings.spectral = spectral
        settings.material = self.material
        settings.diffuse_bounces = self.diffuse
        settings.glossy_bounces = self.glossy
        settings.transmission_bounces = self.transmission
        settings.clamp_indirect = self.clamp_indirect
        settings.noise_threshold = self.noise_threshold
        settings.guiding = self.guiding
        settings.light_tracing = self.light_tracing
        settings.pool = self.pool
        settings.background = self.background
        self.settings = settings

    ## Compile `set` on a thread, or queue it behind the compile in progress.
    func begin(set: interop.Reference[GeometrySet]) -> !:
        self.started = clock.now()
        self.took = 0.0
        if let held = self.waiting:
            var scene = held
            scene.close()
            self.waiting = none
        if let older = self.waiting_set: older.release()
        self.waiting_set = none
        if self.compiling != none:
            if let older = self.queued: older.release()
            self.queued = set.clone()
            return
        try self.spawn(set)

    func spawn(set: interop.Reference[GeometrySet]) -> !:
        # The renderer's geometry again (and the same pool and BVH choice):
        # compile only what a reload needs.
        var reloads = false
        if let running = self.renderer:
            if let held = self.geometry_set:
                let made = running.render_settings()
                reloads = made.pool == self.settings.pool and made.software_bvh == self.settings.software_bvh and (try same_geometry(try set.get(), try held.get()))
        let storage = try (try set.get()).storage()
        let job = new Compiling(set = set.clone(), storage = storage, geometry = not reloads, scene = CompiledScene(), failed = false, message = Growing[u8]()) in memory.heap catch failure:
            dispose_storage(storage)
            error(failure.code, failure.message)
        job.finished.store(0, .relaxed)
        job.thread = thread.spawn(compile_entry, (void*)job, name = "render compile") catch failure:
            release_job(job)
            error(failure.code, failure.message)
        self.compiling = job
        self.compiles += 1

    ## A finished compile becomes the waiting scene; a queued set starts next.
    func collect() -> !:
        let job = self.compiling else return
        if job.finished.load(.acquire) == 0: return
        job.thread.join() catch _: _ = 0
        self.compiling = none
        if self.queued != none:
            # A newer set waits. A finished reload (a light dragged, a set a
            # frame) still shows, so a scene changing every frame is seen
            # changing; a finished upload is superseded by the newer set.
            let next = self.queued else return
            self.queued = none
            defer next.release()
            if not job.failed and not job.geometry:
                self.waiting = job.scene
                self.waiting_reloads = true
                self.waiting_set = job.set.clone()
            else:
                job.scene.close()
            release_job(job)
            try self.spawn(next)
            return
        if job.failed:
            try self.note((str)job.message.view())
            job.scene.close()
        else:
            self.waiting = job.scene
            self.waiting_reloads = not job.geometry
            self.waiting_set = job.set.clone()
        release_job(job)

    ## Make the renderer of the waiting scene (or reload it), on `native`'s device.
    func take_waiting(native: const gpu.RenderTarget*) -> bool!:
        let scene = self.waiting else return true
        var held = scene
        self.waiting = none
        defer held.close()
        let set = self.waiting_set else return true
        self.waiting_set = none
        defer set.release()
        if not self.device.is_open():
            self.device = gpu.device_of(native) catch failure:
                if failure.code == gpu.unavailable: return false
                error(failure.code, failure.message)
        var frame = self.framing
        if not self.viewing:
            let camera = find_camera_path(&held, (str)self.camera_path.view()) catch failure:
                try self.note(failure.message)
                return false
            frame = try ray_frame(held.objects.object(camera), self.settings.width, self.settings.height)
        if self.waiting_reloads:
            if let running = self.renderer:
                var renderer = running
                renderer.reload(&held, self.settings) catch failure:
                    try self.note(failure.message)
                    self.stop()
                    return false
                renderer.restart(frame) catch failure:
                    try self.note(failure.message)
                    self.stop()
                    return false
                self.renderer = renderer
                self.reloads += 1
                return true
        self.destroy_renderer()
        var made = Renderer.create_viewed(self.device, &held, self.settings, frame) catch failure:
            try self.note(failure.message)
            return false
        made.set_display(self.exposure_stops, self.view) catch failure:
            made.destroy()
            error(failure.code, failure.message)
        self.renderer = made
        self.geometry_set = set.clone()
        self.uploads += 1
        return true

    ## Advance the render a pass and draw it fitted into (x, y, width, height) of
    ## `target`; whether passes are still coming.
    pub func draw(target: interop.View[gpu.RenderTarget], x: f64, y: f64, width: f64, height: f64) -> bool!:
        let busy = try self.advance(target)
        try self.show(target, x, y, width, height)
        return busy

    ## Advance the render a pass, drawing nothing (a viewport that shows
    ## something else until the image suits it); whether passes are still
    ## coming.
    pub func advance(target: interop.View[gpu.RenderTarget]) -> bool!:
        let native = try target.get()
        try self.collect()
        if not (try self.take_waiting(native)): return false
        let running = self.renderer else return self.compiling != none
        var renderer = running
        let busy = renderer.advance() catch failure:
            try self.note(failure.message)
            self.stop()
            return false
        self.renderer = renderer
        if not busy and self.took == 0.0 and self.compiling == none: self.took = self.started.elapsed().seconds()
        return busy or self.compiling != none

    ## Draw the image shown, if any, fitted into (x, y, width, height) of
    ## `target`.
    pub func show(target: interop.View[gpu.RenderTarget], x: f64, y: f64, width: f64, height: f64) -> !:
        let renderer = self.renderer else return
        let shown = renderer.shown_size()
        if shown[0] == 0 or shown[1] == 0: return
        let native = try target.get()
        let image_width = (f64)shown[0]
        let image_height = (f64)shown[1]
        let scale = math.min(width / image_width, height / image_height)
        let shown_width = image_width * scale
        let shown_height = image_height * scale
        let area = gpu.Rect(x + 0.5 * (width - shown_width), y + 0.5 * (height - shown_height), shown_width, shown_height)
        try gpu.draw_image(native, renderer.display(), area, gpu.Region(0, 0, shown[0], shown[1]), 1.0, gpu.Filter.linear)

    func note(message: str) -> !:
        self.problem_text.clear()
        try append_text(&self.problem_text, message)

    ## Whether a render is in progress, compiling or waiting for its first draw.
    pub func running() -> bool:
        if self.compiling != none or self.waiting != none: return true
        let renderer = self.renderer else return false
        return renderer.samples_done() < self.settings.samples

    ## Whether a scene is compiling (the image shown, if any, is the last scene's).
    pub func compiling_scene() -> bool:
        return self.compiling != none or self.waiting != none

    pub func has_image() -> bool:
        let renderer = self.renderer else return false
        return renderer.shown_size()[0] > 0

    ## The size of the image `show` draws, in pixels (0 without one): the
    ## size of the view it was rendered through, which may be an earlier
    ## view's (the image stays until the current view's first whole sample).
    pub func shown_width() -> i64:
        let renderer = self.renderer else return 0
        return (i64)renderer.shown_size()[0]

    pub func shown_height() -> i64:
        let renderer = self.renderer else return 0
        return (i64)renderer.shown_size()[1]

    pub func samples_done() -> i64:
        let renderer = self.renderer else return 0
        return (i64)renderer.samples_done()

    pub func samples() -> i64:
        return (i64)self.settings.samples

    pub func width() -> i64:
        return (i64)self.settings.width

    pub func height() -> i64:
        return (i64)self.settings.height

    pub func spectral() -> bool:
        return self.settings.spectral

    ## Compiles started, renderers made (geometry uploaded) and reloads
    ## (geometry kept) over the session.
    pub func compile_count() -> i64:
        return self.compiles

    pub func upload_count() -> i64:
        return self.uploads

    pub func reload_count() -> i64:
        return self.reloads

    ## Seconds since the render started, or what it took once finished.
    pub func seconds() -> f64:
        if self.took > 0.0: return self.took
        return self.started.elapsed().seconds()

    ## Why the last render could not start or stopped ("" when nothing went wrong).
    pub func problem() -> interop.Owned[str]!:
        return try interop.copy_text((str)self.problem_text.view())

    pub func exposure() -> f64:
        return self.exposure_stops

    ## Display exposure in stops and view (0 standard, 1 neutral tone mapping).
    pub func set_display(exposure: f64, view: i64) -> !:
        self.exposure_stops = exposure
        self.view = view
        if let running = self.renderer:
            var renderer = running
            try renderer.set_display(exposure, view)
            self.renderer = renderer

    ## End the render; its image goes too. A compile in progress is waited for.
    pub func stop():
        if let job = self.compiling:
            job.thread.join() catch _: _ = 0
            job.scene.close()
            release_job(job)
            self.compiling = none
        if let next = self.queued: next.release()
        self.queued = none
        if let scene = self.waiting:
            var held = scene
            held.close()
            self.waiting = none
        if let set = self.waiting_set: set.release()
        self.waiting_set = none
        self.destroy_renderer()

    func destroy_renderer():
        if let running = self.renderer:
            var renderer = running
            renderer.destroy()
            self.renderer = none
        if let set = self.geometry_set: set.release()
        self.geometry_set = none

    pub func close():
        self.stop()
        if self.device.is_open(): self.device.destroy()
        self.problem_text.close()
        self.camera_path.close()

pub let render_session_type: interop.Type[RenderSession] = interop.Type[RenderSession]("RenderSession", RenderSession.close)

## Free a collected (or never started) compile: its set, storage and message.
func release_job(job: Compiling*):
    job.set.release()
    dispose_storage(job.storage)
    job.message.close()
    free(job) in memory.heap

func dispose_storage(storage: GeometrySet*):
    storage.close()
    free(storage) in memory.heap

## The camera at `path` ("" the first camera).
func find_camera_path(scene: const CompiledScene*, path: str) -> usize!:
    for at in 0..<scene.objects.count():
        if scene.objects.object(at).kind != SceneKind.camera: continue
        if path == "" or scene.objects.path(at) == path: return at
    error(invalid, "the scene has no camera" if path == "" else "no camera at that path")