Method final_image

examples/cuda/cpu/path_tracer/src/cuda/mod.rs:117–190

Run postprocessing on the accumulated buffer, color correct it, and divide it by the total samples to yield a final image that can be displayed. Also returns the denoising time and postprocessing time.

(
        &mut self,
        cur_sample: usize,
        denoise: bool,
    )

    ///
    /// Also returns the denoising time and postprocessing time.
    pub fn final_image(
        &mut self,
        cur_sample: usize,
        denoise: bool,
    ) -> CudaResult<(&[Vec3<u8>], Duration, Duration)> {
        let module = &self.module;
        let stream = &self.stream;

        let (blocks, threads) = self.launch_dimensions();
        let width = self.buffers.viewport.bounds.x as u32;
        let height = self.buffers.viewport.bounds.y as u32;

        let start = Event::new(EventFlags::DEFAULT)?;
        let denoising_stop = Event::new(EventFlags::DEFAULT)?;
        let postprocessing_stop = Event::new(EventFlags::DEFAULT)?;

        start.record(stream)?;

        unsafe {
            launch!(
                module.scale_buffer<<<blocks, threads, 0, stream>>>(
                    self.buffers.accumulated_buffer.as_device_ptr(),
                    self.buffers.scaled_buffer.as_device_ptr(),
                    cur_sample,
                    self.buffers.viewport
                )
            )?;
        }

        let input_buf = if denoise {
            let input_image = Image::new(
                &self.buffers.scaled_buffer,
                ImageFormat::Float3,
                width,
                height,
            );

            self.denoiser
                .invoke(
                    stream,
                    Default::default(),
                    input_image,
                    Default::default(),
                    &mut self.buffers.denoised_buffer,
                )
                .unwrap();

            self.buffers.denoised_buffer.as_device_ptr()
        } else {
            self.buffers.scaled_buffer.as_device_ptr()
        };

        denoising_stop.record(stream)?;

        unsafe {
            launch!(
                module.postprocess<<<blocks, threads, 0, stream>>>(
                    input_buf,