Differential D12309 Diff 41286 intern/cycles/integrator/path_trace.h

Changeset View

Standalone View

intern/cycles/integrator/path_trace.h

Show All 31 Lines
class Device;		class Device;
class DeviceScene;		class DeviceScene;
class Film;		class Film;
class RenderBuffers;		class RenderBuffers;
class RenderScheduler;		class RenderScheduler;
class RenderWork;		class RenderWork;
class Progress;		class Progress;
class GPUDisplay;		class GPUDisplay;
		class TileManager;

/* PathTrace class takes care of kernel graph and scheduling on a (multi)device. It takes care of		/* PathTrace class takes care of kernel graph and scheduling on a (multi)device. It takes care of
* all the common steps of path tracing which are not device-specific. The list of tasks includes		* all the common steps of path tracing which are not device-specific. The list of tasks includes
* but is not limited to:		* but is not limited to:
* - Kernel graph.		* - Kernel graph.
* - Scheduling logic.		* - Scheduling logic.
* - Queues management.		* - Queues management.
* - Adaptive stopping. */		* - Adaptive stopping. */
class PathTrace {		class PathTrace {
public:		public:
/* Render scheduler is used to report timing information and access things like start/finish		/* Render scheduler is used to report timing information and access things like start/finish
* sample. */		* sample. */
PathTrace(Device *device,		PathTrace(Device *device,
Film *film,		Film *film,
DeviceScene *device_scene,		DeviceScene *device_scene,
RenderScheduler &render_scheduler);		RenderScheduler &render_scheduler,
		TileManager &tile_manager);

/* Create devices and load kernels which are created on-demand (for example, denoising devices).		/* Create devices and load kernels which are created on-demand (for example, denoising devices).
* The progress is reported to the currently configure progress object (via `set_progress`). */		* The progress is reported to the currently configure progress object (via `set_progress`). */
void load_kernels();		void load_kernels();

/* Allocate working memory. This runs before allocating scene memory so that we can estimate		/* Allocate working memory. This runs before allocating scene memory so that we can estimate
* more accurately which scene device memory may need to allocated on the host. */		* more accurately which scene device memory may need to allocated on the host. */
void alloc_work_memory();		void alloc_work_memory();
Show All 37 Lines	public:

/* Cancel rendering process as soon as possible, without waiting for full tile to be sampled.		/* Cancel rendering process as soon as possible, without waiting for full tile to be sampled.
* Used in cases like reset of render session.		* Used in cases like reset of render session.
*		*
* This is a blockign call, which returns as soon as there is no running `render_samples()` call.		* This is a blockign call, which returns as soon as there is no running `render_samples()` call.
*/		*/
void cancel();		void cancel();

/* Copy an entire render buffer to/from the oath trace. */		/* Copy an entire render buffer to/from the path trace. */

/* Copy happens via CPU side buffer: data will be copied from every device of the path trace, and		/* Copy happens via CPU side buffer: data will be copied from every device of the path trace, and
* the data will be copied to the device of the given render buffers. */		* the data will be copied to the device of the given render buffers. */
void copy_to_render_buffers(RenderBuffers *render_buffers);		void copy_to_render_buffers(RenderBuffers *render_buffers);

/* Copy happens via CPU side buffer: data will be copied from the device of the given rendetr		/* Copy happens via CPU side buffer: data will be copied from the device of the given rendetr
* buffers and will be copied to all devices of the path trace. */		* buffers and will be copied to all devices of the path trace. */
void copy_from_render_buffers(RenderBuffers *render_buffers);		void copy_from_render_buffers(RenderBuffers *render_buffers);

/* Copy render buffers of the big tile from the device to hsot.		/* Copy render buffers of the big tile from the device to hsot.
* Return true if all copies are successful. */		* Return true if all copies are successful. */
bool copy_render_tile_from_device();		bool copy_render_tile_from_device();

		/* Get number of samples in the current big tile render buffers. */
		int get_num_render_tile_samples() const;

/* Get pass data of the entire big tile.		/* Get pass data of the entire big tile.
* This call puts pass render result from all devices into the final pixels storage.		* This call puts pass render result from all devices into the final pixels storage.
*		*
* NOTE: Expects buffers to be copied to the host using `copy_render_tile_from_device()`.		* NOTE: Expects buffers to be copied to the host using `copy_render_tile_from_device()`.
*		*
* Returns false if any of the accessor's `get_render_tile_pixels()` returned false. */		* Returns false if any of the accessor's `get_render_tile_pixels()` returned false. */
bool get_render_tile_pixels(const PassAccessor &pass_accessor,		bool get_render_tile_pixels(const PassAccessor &pass_accessor,
const PassAccessor::Destination &destination);		const PassAccessor::Destination &destination);

/* Set pass data for baking. */		/* Set pass data for baking. */
bool set_render_tile_pixels(PassAccessor &pass_accessor, const PassAccessor::Source &source);		bool set_render_tile_pixels(PassAccessor &pass_accessor, const PassAccessor::Source &source);

/* Check whether denoiser was run and denoised passes are available. */		/* Check whether denoiser was run and denoised passes are available. */
bool has_denoised_result() const;		bool has_denoised_result() const;

		/* Get size and offset (relative to the buffer's full x/y) of the currently rendering tile.
		* In the case of tiled rendering this will return full-frame after all tiles has been rendered.
		*/
		int2 get_render_tile_size() const;
		int2 get_render_tile_offset() const;

		bool get_render_tile_done() const;

/* Generate full multi-line report of the rendering process, including rendering parameters,		/* Generate full multi-line report of the rendering process, including rendering parameters,
* times, and so on. */		* times, and so on. */
string full_report() const;		string full_report() const;

/* Callback which communicates an updates state of the render buffer.		/* Callback which communicates an updates state of the render buffer of the current big tile.
* Is called during path tracing to communicate work-in-progress state of the final buffer.		* Is called during path tracing to communicate work-in-progress state of the final buffer. */
*		function<void(void)> tile_buffer_update_cb;
* The samples indicates how many samples the buffer contains. */
function<void(void)> buffer_update_cb;

/* Callback which communicates final rendered buffer. Is called after pathtracing is done.		/* Callback which communicates final rendered buffer. Is called after pathtracing is done. */
*		function<void(void)> tile_buffer_write_cb;
* The samples indicates how many samples the buffer contains. */
function<void(void)> buffer_write_cb;

/* Callback which initializes rendered buffer. Is called before pathtracing starts.		/* Callback which initializes rendered buffer. Is called before pathtracing starts.
*		*
* This is used for baking. */		* This is used for baking. */
function<bool(void)> buffer_read_cb;		function<bool(void)> tile_buffer_read_cb;

/* Callback which is called to report current rendering progress.		/* Callback which is called to report current rendering progress.
*		*
* It is supposed to be cheaper than buffer update/write, hence can be called more often.		* It is supposed to be cheaper than buffer update/write, hence can be called more often.
* Additionally, it might be called form the middle of wavefront (meaning, it is not guaranteed		* Additionally, it might be called form the middle of wavefront (meaning, it is not guaranteed
* that the buffer is "uniformly" sampled at the moment of this callback). */		* that the buffer is "uniformly" sampled at the moment of this callback). */
function<void(void)> progress_update_cb;		function<void(void)> progress_update_cb;

Show All 17 Lines	protected:

/* Perform various steps of the render work.		/* Perform various steps of the render work.
*		*
* Note that some steps might modify the work, forcing some steps to happen within this iteration		* Note that some steps might modify the work, forcing some steps to happen within this iteration
* of rendering. */		* of rendering. */
void init_render_buffers(const RenderWork &render_work);		void init_render_buffers(const RenderWork &render_work);
void path_trace(RenderWork &render_work);		void path_trace(RenderWork &render_work);
void adaptive_sample(RenderWork &render_work);		void adaptive_sample(RenderWork &render_work);
void denoise(const RenderWork &render_work);		void denoise(const RenderWork &render_work);
		brechtUnsubmitted Not Done Inline Actions Not sure why this one gets the `_tile` postfix while other functions don't. brecht: Not sure why this one gets the `_tile` postfix while other functions don't.
		sergeyAuthorUnsubmitted Done Inline Actions Got confusing at some point during development, so had to disambiguate. But happy with the naming you've suggested in the review, so will remove the _tile suffix. sergey: Got confusing at some point during development, so had to disambiguate. But happy with the…
void cryptomatte_postprocess(const RenderWork &render_work);		void cryptomatte_postprocess(const RenderWork &render_work);
void update_display(const RenderWork &render_work);		void update_display(const RenderWork &render_work);
void rebalance(const RenderWork &render_work);		void rebalance(const RenderWork &render_work);
		void write_tile_buffer(const RenderWork &render_work);
		brechtUnsubmitted Done Inline Actions Would prefer a name like `write_tile_buffer_to_disk`. Since writing can mean multiple things, some indication that this is about writing to disk helps. Also we generally use "buffer" instead of "result" in Cycles. brecht: Would prefer a name like `write_tile_buffer_to_disk`. Since writing can mean multiple things…
		void process_full_buffer_from_disk(const RenderWork &render_work);
		brechtUnsubmitted Done Inline Actions I suggest `process_full_buffer_from_disk`. brecht: I suggest `process_full_buffer_from_disk`.

/* Get number of samples in the current state of the render buffers. */		/* Get number of samples in the current state of the render buffers. */
int get_num_samples_in_buffer();		int get_num_samples_in_buffer();

/* Check whether user requested to cancel rendering, so that path tracing is to be finished as		/* Check whether user requested to cancel rendering, so that path tracing is to be finished as
* soon as possible. */		* soon as possible. */
bool is_cancel_requested();		bool is_cancel_requested();

/* Write the big tile render buffer via the write callback. */		/* Write the big tile render buffer via the write callback. */
void buffer_write();		void tile_buffer_write();

/* Read the big tile render buffer via the read callback. */		/* Read the big tile render buffer via the read callback. */
void buffer_read();		void tile_buffer_read();

		/* Write current tile into the file on disk. */
		void tile_buffer_write_to_disk();

		/* Read full-frame render result from a file on disk. */
		void read_full_buffer_from_disk();

/* Run the progress_update_cb callback if it is needed. */		/* Run the progress_update_cb callback if it is needed. */
void progress_update_if_needed();		void progress_update_if_needed();

/* Pointer to a device which is configured to be used for path tracing. If multiple devices		/* Pointer to a device which is configured to be used for path tracing. If multiple devices
* are configured this is a `MultiDevice`. */		* are configured this is a `MultiDevice`. */
Device *device_ = nullptr;		Device *device_ = nullptr;

		/* CPU device for creating temporary render buffers on the CPU side. */
		unique_ptr<Device> cpu_device_;

DeviceScene *device_scene_;		DeviceScene *device_scene_;

RenderScheduler &render_scheduler_;		RenderScheduler &render_scheduler_;
		TileManager &tile_manager_;

unique_ptr<GPUDisplay> gpu_display_;		unique_ptr<GPUDisplay> gpu_display_;

/* Per-compute device descriptors of work which is responsible for path tracing on its configured		/* Per-compute device descriptors of work which is responsible for path tracing on its configured
* device. */		* device. */
vector<unique_ptr<PathTraceWork>> path_trace_works_;		vector<unique_ptr<PathTraceWork>> path_trace_works_;

/* Per-path trace work information needed for multi-device balancing. */		/* Per-path trace work information needed for multi-device balancing. */
Show All 20 Lines	struct {
* affects both resolution and stride as visible by the integrator kernels. */		* affects both resolution and stride as visible by the integrator kernels. */
int resolution_divider = 0;		int resolution_divider = 0;

/* Paramaters of the big tile with the current resolution divider applied. */		/* Paramaters of the big tile with the current resolution divider applied. */
BufferParams effective_big_tile_params;		BufferParams effective_big_tile_params;

/* Denosier was run and there are denoised versions of the passes in the render buffers. */		/* Denosier was run and there are denoised versions of the passes in the render buffers. */
bool has_denoised_result = false;		bool has_denoised_result = false;

		/* Current tile has been written (to either disk or callback.
		* Indicates that no more work will be done on this tile. */
		bool tile_written = false;
} render_state_;		} render_state_;

/* Progress object which is used to communicate sample progress. */		/* Progress object which is used to communicate sample progress. */
Progress *progress_;		Progress *progress_;

/* Fields required for canceling render on demand, as quickly as possible. */		/* Fields required for canceling render on demand, as quickly as possible. */
struct {		struct {
/* Indicates whether there is an on-going `render_samples()` call. */		/* Indicates whether there is an on-going `render_samples()` call. */
bool is_rendering = false;		bool is_rendering = false;

/* Indicates whether rendering is requested to be canceled by `cancel()`. */		/* Indicates whether rendering is requested to be canceled by `cancel()`. */
bool is_requested = false;		bool is_requested = false;

/* Synchronization between thread which does `render_samples()` and thread which does		/* Synchronization between thread which does `render_samples()` and thread which does
* `cancel()`. */		* `cancel()`. */
thread_mutex mutex;		thread_mutex mutex;
thread_condition_variable condition;		thread_condition_variable condition;
} render_cancel_;		} render_cancel_;

/* Indicates whether a render result was drawn after latest session reset.		/* Indicates whether a render result was drawn after latest session reset.
* Used by `ready_to_reset()` to implement logic which feels the most interactive. */		* Used by `ready_to_reset()` to implement logic which feels the most interactive. */
bool did_draw_after_reset_ = true;		bool did_draw_after_reset_ = true;

		unique_ptr<RenderBuffers> full_frame_buffers_;
};		};

CCL_NAMESPACE_END		CCL_NAMESPACE_END