Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-render

Source of release 0.1.1

0.1.1 / src / render / session.lucb

#==============================================================================================
#
#   render/session - A progressive render an application shows
#
#   DESCRIPTION:
#       RenderSession is what a Luce application holds: `start` compiles a GeometrySet
#       on the CPU, and each `draw` into a view's target 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, on the device the view draws with.
#       `draw` returns whether more passes are coming, so the view can ask for another
#       frame.
#
#==============================================================================================

pub struct RenderSession:
    var device: gpu.Device
    ## A compiled scene waiting for the first draw's device.
    var waiting: CompiledScene?
    var settings: RenderSettings
    var renderer: Renderer?
    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

    pub func init():
        self.device = gpu.Device()
        self.waiting = none
        self.settings = RenderSettings.of(1, 1, 1)
        self.renderer = none
        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

    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) -> !:
        self.stop()
        self.problem_text.clear()
        if width < 1 or height < 1 or width > 16384 or height > 16384: error(invalid, "an image is 1 to 16384 pixels on a side")
        if samples < 1 or bounces < 1 or bounces > 1024: error(invalid, "a render needs samples and 1 to 1024 bounces")
        var scene = try compile_scene(try set.get())
        errdefer scene.close()
        var index: i64 = -1
        for at in 0..<scene.objects.count():
            if scene.objects.object(at).kind != SceneKind.camera: continue
            if camera == "" or scene.objects.path(at) == camera:
                index = (i64)at
                break
        if index < 0: error(invalid, "the scene has no camera" if camera == "" else "no camera at that path")
        var settings = RenderSettings.of((u32)width, (u32)height, (u32)samples)
        settings.max_bounces = (u32)bounces
        settings.spectral = spectral
        settings.camera = index
        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
        self.settings = settings
        self.waiting = scene
        self.started = clock.now()
        self.took = 0.0

    ## 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)

    ## 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 native = try target.get()
        if let scene = self.waiting:
            var held = scene
            self.waiting = none
            defer held.close()
            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 made = Renderer.create(self.device, &held, self.settings) 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.started = clock.now()
        let running = self.renderer else return false
        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: self.took = self.started.elapsed().seconds()
        let image_width = (f64)self.settings.width
        let image_height = (f64)self.settings.height
        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, none, 1.0, gpu.Filter.linear)
        return busy

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

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

    pub func has_image() -> bool:
        return self.renderer != none

    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

    ## 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.
    pub func stop():
        if let scene = self.waiting:
            var held = scene
            held.close()
            self.waiting = none
        if let running = self.renderer:
            var renderer = running
            renderer.destroy()
            self.renderer = none

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

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