Differential D12515 Diff 41972 intern/cycles/blender/blender_session.cpp

Changeset View

Standalone View

intern/cycles/blender/blender_session.cpp

Show First 20 Lines • Show All 116 Lines • ▼ Show 20 Lines

BlenderSession::~BlenderSession()		BlenderSession::~BlenderSession()
{		{
free_session();		free_session();
}		}

void BlenderSession::create_session()		void BlenderSession::create_session()
{		{
SessionParams session_params = BlenderSync::get_session_params(		const SessionParams session_params = BlenderSync::get_session_params(
b_engine, b_userpref, b_scene, background);		b_engine, b_userpref, b_scene, background);
SceneParams scene_params = BlenderSync::get_scene_params(b_scene, background);		const SceneParams scene_params = BlenderSync::get_scene_params(b_scene, background);
bool session_pause = BlenderSync::get_session_pause(b_scene, background);		const bool session_pause = BlenderSync::get_session_pause(b_scene, background);

/* reset status/progress */		/* reset status/progress */
last_status = "";		last_status = "";
last_error = "";		last_error = "";
last_progress = -1.0f;		last_progress = -1.0f;
start_resize_time = 0.0;		start_resize_time = 0.0;

/* create session */		/* create session */
Show All 13 Lines	void BlenderSession::create_session()
if (b_v3d) {		if (b_v3d) {
sync->sync_view(b_v3d, b_rv3d, width, height);		sync->sync_view(b_v3d, b_rv3d, width, height);
}		}
else {		else {
sync->sync_camera(b_render, b_camera_override, width, height, "");		sync->sync_camera(b_render, b_camera_override, width, height, "");
}		}

/* set buffer parameters */		/* set buffer parameters */
BufferParams buffer_params = BlenderSync::get_buffer_params(		const 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(session_params, buffer_params);

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

/* Viewport and preview (as in, material preview) does not do tiled rendering, so can inform		/* Viewport and preview (as in, material preview) does not do tiled rendering, so can inform
* engine that no tracking of the tiles state is needed.		* engine that no tracking of the tiles state is needed.
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines	void BlenderSession::reset_session(BL::BlendData &b_data, BL::Depsgraph &b_depsgraph)

if (b_v3d) {		if (b_v3d) {
/* NOTE: We need to create session, but all the code from below		/* NOTE: We need to create session, but all the code from below
* will make viewport render to stuck on initialization.		* will make viewport render to stuck on initialization.
*/		*/
return;		return;
}		}

SessionParams session_params = BlenderSync::get_session_params(		const SessionParams session_params = BlenderSync::get_session_params(
b_engine, b_userpref, b_scene, background);		b_engine, b_userpref, b_scene, background);
SceneParams scene_params = BlenderSync::get_scene_params(b_scene, background);		const SceneParams scene_params = BlenderSync::get_scene_params(b_scene, background);

if (scene->params.modified(scene_params) \|\| session->params.modified(session_params) \|\|		if (scene->params.modified(scene_params) \|\| session->params.modified(session_params) \|\|
!this->b_render.use_persistent_data()) {		!this->b_render.use_persistent_data()) {
/* if scene or session parameters changed, it's easier to simply re-create		/* if scene or session parameters changed, it's easier to simply re-create
* them rather than trying to distinguish which settings need to be updated		* them rather than trying to distinguish which settings need to be updated
*/		*/
if (!is_new_session) {		if (!is_new_session) {
free_session();		free_session();
Show All 20 Lines	else {
sync->sync_recalc(b_depsgraph, b_v3d);		sync->sync_recalc(b_depsgraph, b_v3d);
}		}

BL::Object b_camera_override(b_engine.camera_override());		BL::Object b_camera_override(b_engine.camera_override());
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(		const 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(session_params, buffer_params);

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

{		{
thread_scoped_lock lock(draw_state_.mutex);		thread_scoped_lock lock(draw_state_.mutex);
draw_state_.last_pass_index = -1;		draw_state_.last_pass_index = -1;
}		}
▲ Show 20 Lines • Show All 151 Lines • ▼ Show 20 Lines	void BlenderSession::render(BL::Depsgraph &b_depsgraph_)
/* TODO(sergey): Investigate whether GPUDisplay can be used for the preview as well. */		/* TODO(sergey): Investigate whether GPUDisplay can be used for the preview as well. */
if (b_engine.is_preview()) {		if (b_engine.is_preview()) {
session->update_render_tile_cb = [&]() { write_render_tile(); };		session->update_render_tile_cb = [&]() { write_render_tile(); };
}		}

BL::ViewLayer b_view_layer = b_depsgraph.view_layer_eval();		BL::ViewLayer b_view_layer = b_depsgraph.view_layer_eval();

/* get buffer parameters */		/* get buffer parameters */
SessionParams session_params = BlenderSync::get_session_params(		const SessionParams session_params = BlenderSync::get_session_params(
b_engine, b_userpref, b_scene, background);		b_engine, b_userpref, b_scene, background);
BufferParams buffer_params = BlenderSync::get_buffer_params(		BufferParams buffer_params = BlenderSync::get_buffer_params(
b_v3d, b_rv3d, scene->camera, width, height);		b_v3d, b_rv3d, scene->camera, width, height);

/* temporary render result to find needed passes and views */		/* temporary render result to find needed passes and views */
BL::RenderResult b_rr = b_engine.begin_result(0, 0, 1, 1, b_view_layer.name().c_str(), NULL);		BL::RenderResult b_rr = b_engine.begin_result(0, 0, 1, 1, b_view_layer.name().c_str(), NULL);
BL::RenderResult::layers_iterator b_single_rlay;		BL::RenderResult::layers_iterator b_single_rlay;
b_rr.layers.begin(b_single_rlay);		b_rr.layers.begin(b_single_rlay);
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines	for (b_rr.views.begin(b_view_iter); b_view_iter != b_rr.views.end();
*/		*/
if (view_index != 0) {		if (view_index != 0) {
int seed = scene->integrator->get_seed();		int seed = scene->integrator->get_seed();
seed += hash_uint2(seed, hash_uint2(view_index * 0xdeadbeef, 0));		seed += hash_uint2(seed, hash_uint2(view_index * 0xdeadbeef, 0));
scene->integrator->set_seed(seed);		scene->integrator->set_seed(seed);
}		}

/* Update number of samples per layer. */		/* Update number of samples per layer. */
int samples = sync->get_layer_samples();		const int samples = sync->get_layer_samples();
bool bound_samples = sync->get_layer_bound_samples();		const bool bound_samples = sync->get_layer_bound_samples();
int effective_layer_samples;

if (samples != 0 && (!bound_samples \|\| (samples < session_params.samples)))		SessionParams effective_session_params = session_params;
effective_layer_samples = samples;		if (samples != 0 && (!bound_samples \|\| (samples < session_params.samples))) {
else		effective_session_params.samples = samples;
effective_layer_samples = session_params.samples;		}

/* Update tile manager if we're doing resumable render. */		/* Update tile manager if we're doing resumable render. */
update_resumable_tile_manager(effective_layer_samples);		update_resumable_tile_manager(effective_session_params.samples);

/* Update session itself. */		/* Update session itself. */
session->reset(buffer_params, effective_layer_samples);		session->reset(effective_session_params, buffer_params);

/* render */		/* render */
if (!b_engine.is_preview() && background && print_render_stats) {		if (!b_engine.is_preview() && background && print_render_stats) {
scene->enable_update_stats();		scene->enable_update_stats();
}		}

session->start();		session->start();
session->wait();		session->wait();
▲ Show 20 Lines • Show All 145 Lines • ▼ Show 20 Lines	foreach (Object *ob, scene->objects) {
if (ob->name == b_object.name()) {		if (ob->name == b_object.name()) {
object_found = true;		object_found = true;
break;		break;
}		}
}		}

if (object_found && !session->progress.get_cancel()) {		if (object_found && !session->progress.get_cancel()) {
/* Get session and buffer parameters. */		/* Get session and buffer parameters. */
SessionParams session_params = BlenderSync::get_session_params(		const SessionParams session_params = BlenderSync::get_session_params(
b_engine, b_userpref, b_scene, background);		b_engine, b_userpref, b_scene, background);

BufferParams buffer_params;		BufferParams buffer_params;
buffer_params.width = bake_width;		buffer_params.width = bake_width;
buffer_params.height = bake_height;		buffer_params.height = bake_height;

/* Update session. */		/* Update session. */
session->reset(buffer_params, session_params.samples);		session->reset(session_params, buffer_params);

session->progress.set_update_callback(		session->progress.set_update_callback(
function_bind(&BlenderSession::update_bake_progress, this));		function_bind(&BlenderSession::update_bake_progress, this));
}		}

/* Perform bake. Check cancel to avoid crash with incomplete scene data. */		/* Perform bake. Check cancel to avoid crash with incomplete scene data. */
if (object_found && !session->progress.get_cancel()) {		if (object_found && !session->progress.get_cancel()) {
session->start();		session->start();
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines

void BlenderSession::synchronize(BL::Depsgraph &b_depsgraph_)		void BlenderSession::synchronize(BL::Depsgraph &b_depsgraph_)
{		{
/* only used for viewport render */		/* only used for viewport render */
if (!b_v3d)		if (!b_v3d)
return;		return;

/* on session/scene parameter changes, we recreate session entirely */		/* on session/scene parameter changes, we recreate session entirely */
SessionParams session_params = BlenderSync::get_session_params(		const SessionParams session_params = BlenderSync::get_session_params(
b_engine, b_userpref, b_scene, background);		b_engine, b_userpref, b_scene, background);
SceneParams scene_params = BlenderSync::get_scene_params(b_scene, background);		const SceneParams scene_params = BlenderSync::get_scene_params(b_scene, background);
bool session_pause = BlenderSync::get_session_pause(b_scene, background);		const bool session_pause = BlenderSync::get_session_pause(b_scene, background);

if (session->params.modified(session_params) \|\| scene->params.modified(scene_params)) {		if (session->params.modified(session_params) \|\| scene->params.modified(scene_params)) {
free_session();		free_session();
create_session();		create_session();
}		}

/* increase samples and render time, but never decrease */		/* increase samples and render time, but never decrease */
session->set_samples(session_params.samples);		session->set_samples(session_params.samples);
Show All 24 Lines	sync->sync_data(
b_render, b_depsgraph, b_v3d, b_camera_override, width, height, &python_thread_state);		b_render, b_depsgraph, b_v3d, b_camera_override, width, height, &python_thread_state);

if (b_rv3d)		if (b_rv3d)
sync->sync_view(b_v3d, b_rv3d, width, height);		sync->sync_view(b_v3d, b_rv3d, width, height);
else		else
sync->sync_camera(b_render, b_camera_override, width, height, "");		sync->sync_camera(b_render, b_camera_override, width, height, "");

/* get buffer parameters */		/* get buffer parameters */
BufferParams buffer_params = BlenderSync::get_buffer_params(		const BufferParams buffer_params = BlenderSync::get_buffer_params(
b_v3d, b_rv3d, scene->camera, width, height);		b_v3d, b_rv3d, scene->camera, width, height);

/* reset if needed */		/* reset if needed */
if (scene->need_reset()) {		if (scene->need_reset()) {
session->reset(buffer_params, session_params.samples);		session->reset(session_params, buffer_params);

/* After session reset, so device is not accessing image data anymore. */		/* After session reset, so device is not accessing image data anymore. */
builtin_images_load();		builtin_images_load();

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

▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines	else {
if (scene->camera->is_modified())		if (scene->camera->is_modified())
reset = true;		reset = true;

session->scene->mutex.unlock();		session->scene->mutex.unlock();
}		}

/* reset if requested */		/* reset if requested */
if (reset) {		if (reset) {
SessionParams session_params = BlenderSync::get_session_params(		const SessionParams session_params = BlenderSync::get_session_params(
b_engine, b_userpref, b_scene, background);		b_engine, b_userpref, b_scene, background);
BufferParams buffer_params = BlenderSync::get_buffer_params(		const BufferParams buffer_params = BlenderSync::get_buffer_params(
b_v3d, b_rv3d, scene->camera, width, height);		b_v3d, b_rv3d, scene->camera, width, height);
bool session_pause = BlenderSync::get_session_pause(b_scene, background);		const bool session_pause = BlenderSync::get_session_pause(b_scene, background);

if (session_pause == false) {		if (session_pause == false) {
session->reset(buffer_params, session_params.samples);		session->reset(session_params, buffer_params);
start_resize_time = 0.0;		start_resize_time = 0.0;
}		}
}		}
}		}
else {		else {
tag_update();		tag_update();
}		}

▲ Show 20 Lines • Show All 194 Lines • Show Last 20 Lines