Differential D12309 Diff 41321 intern/cycles/blender/blender_session.cpp

Changeset View

Standalone View

intern/cycles/blender/blender_session.cpp

Show First 20 Lines • Show All 158 Lines • ▼ Show 20 Lines	BufferParams buffer_params = BlenderSync::get_buffer_params(
b_v3d, b_rv3d, scene->camera, width, height);		b_v3d, b_rv3d, scene->camera, width, height);
session->reset(buffer_params, session_params.samples);		session->reset(buffer_params, session_params.samples);

/* Create GPU display. */		/* Create GPU display. */
if (!background) {		if (!background) {
session->set_gpu_display(make_unique<BlenderGPUDisplay>(b_engine, b_scene));		session->set_gpu_display(make_unique<BlenderGPUDisplay>(b_engine, b_scene));
}		}

/* TODO(sergey): Decide on what is to be communicated to the engine here. There is no tiled		/* Viewport and preview (as in, material preview) does not do tiled rendering, so can inform
* rendering for from visual point of view when render buffer fits big tile. But for huge		* engine that no tracking of the tiles state is needed.
* render resolutions it might still be helpful to see which big tile is being sampled. */		* The offline rendering will make a decision when tile is being written. The penalty of asking
/* b_engine.use_highlight_tiles(session_params.progressive_refine == false); */		* the engine to keep track of tiles state is minimal, so there is nothing to worry about here
		* about possible single-tiled final render. */
		if (!b_engine.is_preview() && !b_v3d) {
		b_engine.use_highlight_tiles(true);
		}

update_resumable_tile_manager(session_params.samples);		update_resumable_tile_manager(session_params.samples);
}		}

void BlenderSession::reset_session(BL::BlendData &b_data, BL::Depsgraph &b_depsgraph)		void BlenderSession::reset_session(BL::BlendData &b_data, BL::Depsgraph &b_depsgraph)
{		{
/* Update data, scene and depsgraph pointers. These can change after undo. */		/* Update data, scene and depsgraph pointers. These can change after undo. */
this->b_data = b_data;		this->b_data = b_data;
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines	void BlenderSession::reset_session(BL::BlendData &b_data, BL::Depsgraph &b_depsgraph)
sync->sync_camera(b_render, b_camera_override, width, height, "");		sync->sync_camera(b_render, b_camera_override, width, height, "");

BL::SpaceView3D b_null_space_view3d(PointerRNA_NULL);		BL::SpaceView3D b_null_space_view3d(PointerRNA_NULL);
BL::RegionView3D b_null_region_view3d(PointerRNA_NULL);		BL::RegionView3D b_null_region_view3d(PointerRNA_NULL);
BufferParams buffer_params = BlenderSync::get_buffer_params(		BufferParams buffer_params = BlenderSync::get_buffer_params(
b_null_space_view3d, b_null_region_view3d, scene->camera, width, height);		b_null_space_view3d, b_null_region_view3d, scene->camera, width, height);
session->reset(buffer_params, session_params.samples);		session->reset(buffer_params, session_params.samples);

/* TODO(sergey): Decice on what is to be communicated to the engine here. There is no tiled
* rendering for from visual point of view when render buffer fits big tile. But for huge
* render resolutions it might still be helpful to see which big tile is being sampled. */
/* TODO(sergey): If some logic is needed here, de-duplicate it with the constructor using some
* sort of utility function. */
/* b_engine.use_highlight_tiles(session_params.progressive_refine == false); */

/* reset time */		/* reset time */
start_resize_time = 0.0;		start_resize_time = 0.0;
}		}

void BlenderSession::free_session()		void BlenderSession::free_session()
{		{
session->cancel(true);		session->cancel(true);

Show All 30 Lines	void BlenderSession::do_write_update_render_tile(bool do_update_only)

if (do_update_only) {		if (do_update_only) {
update_render_result(b_rlay);		update_render_result(b_rlay);
}		}
else {		else {
write_render_result(b_rlay);		write_render_result(b_rlay);
}		}

b_engine.end_result(b_rr, true, false, true);		const bool has_multiple_tiles = session->has_multiple_render_tiles();
		const bool tile_done = session->get_render_tile_done();
		const bool highlight = has_multiple_tiles && do_update_only && !tile_done;

		b_engine.end_result(b_rr, true, highlight, true);
}		}

void BlenderSession::read_render_tile()		void BlenderSession::read_render_tile()
{		{
const int2 tile_offset = session->get_render_tile_offset();		const int2 tile_offset = session->get_render_tile_offset();
const int2 tile_size = session->get_render_tile_size();		const int2 tile_size = session->get_render_tile_size();

/* get render result */		/* get render result */
▲ Show 20 Lines • Show All 209 Lines • ▼ Show 20 Lines	for (b_rr.views.begin(b_view_iter); b_view_iter != b_rr.views.end();
if (session->progress.get_cancel())		if (session->progress.get_cancel())
break;		break;
}		}

/* add metadata */		/* add metadata */
stamp_view_layer_metadata(scene, b_rlay_name);		stamp_view_layer_metadata(scene, b_rlay_name);

/* free result without merging */		/* free result without merging */
b_engine.end_result(b_rr, true, true, false);		b_engine.end_result(b_rr, true, false, false);

double total_time, render_time;		double total_time, render_time;
session->progress.get_time(total_time, render_time);		session->progress.get_time(total_time, render_time);
VLOG(1) << "Total render time: " << total_time;		VLOG(1) << "Total render time: " << total_time;
VLOG(1) << "Render time (without synchronization): " << render_time;		VLOG(1) << "Render time (without synchronization): " << render_time;

/* clear callback */		/* clear callback */
session->write_render_tile_cb = function_null;		session->write_render_tile_cb = function_null;
▲ Show 20 Lines • Show All 517 Lines • Show Last 20 Lines