Differential D10082 Diff 32640 intern/cycles/blender/blender_sync.cpp

Changeset View

Standalone View

intern/cycles/blender/blender_sync.cpp

Show First 20 Lines • Show All 232 Lines • ▼ Show 20 Lines	void BlenderSync::sync_data(BL::RenderSettings &b_render,
sync_integrator();		sync_integrator();
sync_film(b_v3d);		sync_film(b_v3d);
sync_shaders(b_depsgraph, b_v3d);		sync_shaders(b_depsgraph, b_v3d);
sync_images();		sync_images();

geometry_synced.clear(); /* use for objects and motion sync */		geometry_synced.clear(); /* use for objects and motion sync */

if (scene->need_motion() == Scene::MOTION_PASS \|\| scene->need_motion() == Scene::MOTION_NONE \|\|		if (scene->need_motion() == Scene::MOTION_PASS \|\| scene->need_motion() == Scene::MOTION_NONE \|\|
scene->camera->get_motion_position() == Camera::MOTION_POSITION_CENTER) {		scene->get_camera()->get_motion_position() == Camera::MOTION_POSITION_CENTER) {
sync_objects(b_depsgraph, b_v3d);		sync_objects(b_depsgraph, b_v3d);
}		}
sync_motion(b_render, b_depsgraph, b_v3d, b_override, width, height, python_thread_state);		sync_motion(b_render, b_depsgraph, b_v3d, b_override, width, height, python_thread_state);

geometry_synced.clear();		geometry_synced.clear();

/* Shader sync done at the end, since object sync uses it.		/* Shader sync done at the end, since object sync uses it.
* false = don't delete unused shaders, not supported. */		* false = don't delete unused shaders, not supported. */
shader_map.post_sync(false);		shader_map.post_sync(false);

free_data_after_sync(b_depsgraph);		free_data_after_sync(b_depsgraph);

VLOG(1) << "Total time spent synchronizing data: " << timer.get_time();		VLOG(1) << "Total time spent synchronizing data: " << timer.get_time();
}		}

/* Integrator */		/* Integrator */

void BlenderSync::sync_integrator()		void BlenderSync::sync_integrator()
{		{
BL::RenderSettings r = b_scene.render();		BL::RenderSettings r = b_scene.render();
PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");		PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");

experimental = (get_enum(cscene, "feature_set") != 0);		experimental = (get_enum(cscene, "feature_set") != 0);

Integrator *integrator = scene->integrator;		Integrator *integrator = scene->get_integrator();

integrator->set_min_bounce(get_int(cscene, "min_light_bounces"));		integrator->set_min_bounce(get_int(cscene, "min_light_bounces"));
integrator->set_max_bounce(get_int(cscene, "max_bounces"));		integrator->set_max_bounce(get_int(cscene, "max_bounces"));

integrator->set_max_diffuse_bounce(get_int(cscene, "diffuse_bounces"));		integrator->set_max_diffuse_bounce(get_int(cscene, "diffuse_bounces"));
integrator->set_max_glossy_bounce(get_int(cscene, "glossy_bounces"));		integrator->set_max_glossy_bounce(get_int(cscene, "glossy_bounces"));
integrator->set_max_transmission_bounce(get_int(cscene, "transmission_bounces"));		integrator->set_max_transmission_bounce(get_int(cscene, "transmission_bounces"));
integrator->set_max_volume_bounce(get_int(cscene, "volume_bounces"));		integrator->set_max_volume_bounce(get_int(cscene, "volume_bounces"));
Show All 23 Lines	void BlenderSync::sync_integrator()
}		}

integrator->set_seed(seed);		integrator->set_seed(seed);

integrator->set_sample_clamp_direct(get_float(cscene, "sample_clamp_direct"));		integrator->set_sample_clamp_direct(get_float(cscene, "sample_clamp_direct"));
integrator->set_sample_clamp_indirect(get_float(cscene, "sample_clamp_indirect"));		integrator->set_sample_clamp_indirect(get_float(cscene, "sample_clamp_indirect"));
if (!preview) {		if (!preview) {
if (integrator->get_motion_blur() != r.use_motion_blur()) {		if (integrator->get_motion_blur() != r.use_motion_blur()) {
scene->object_manager->tag_update(scene);		scene->get_object_manager()->tag_update(scene);
scene->camera->tag_modified();		scene->get_camera()->tag_modified();
}		}

integrator->set_motion_blur(r.use_motion_blur());		integrator->set_motion_blur(r.use_motion_blur());
}		}

integrator->set_method((Integrator::Method)get_enum(		integrator->set_method((Integrator::Method)get_enum(
cscene, "progressive", Integrator::NUM_METHODS, Integrator::PATH));		cscene, "progressive", Integrator::NUM_METHODS, Integrator::PATH));

▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
}		}

/* Film */		/* Film */

void BlenderSync::sync_film(BL::SpaceView3D &b_v3d)		void BlenderSync::sync_film(BL::SpaceView3D &b_v3d)
{		{
PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");		PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");

Film *film = scene->film;		Film *film = scene->get_film();

vector<Pass> prevpasses = scene->passes;		vector<Pass> prevpasses = scene->get_passes();

if (b_v3d) {		if (b_v3d) {
film->set_display_pass(update_viewport_display_passes(b_v3d, scene->passes));		film->set_display_pass(update_viewport_display_passes(b_v3d, scene->get_passes()));
}		}

film->set_exposure(get_float(cscene, "film_exposure"));		film->set_exposure(get_float(cscene, "film_exposure"));
film->set_filter_type(		film->set_filter_type(
(FilterType)get_enum(cscene, "pixel_filter_type", FILTER_NUM_TYPES, FILTER_BLACKMAN_HARRIS));		(FilterType)get_enum(cscene, "pixel_filter_type", FILTER_NUM_TYPES, FILTER_BLACKMAN_HARRIS));
float filter_width = (film->get_filter_type() == FILTER_BOX) ? 1.0f :		float filter_width = (film->get_filter_type() == FILTER_BOX) ? 1.0f :
get_float(cscene, "filter_width");		get_float(cscene, "filter_width");
film->set_filter_width(filter_width);		film->set_filter_width(filter_width);
Show All 12 Lines	switch (b_mist.falloff()) {
film->set_mist_falloff(1.0f);		film->set_mist_falloff(1.0f);
break;		break;
case BL::WorldMistSettings::falloff_INVERSE_QUADRATIC:		case BL::WorldMistSettings::falloff_INVERSE_QUADRATIC:
film->set_mist_falloff(0.5f);		film->set_mist_falloff(0.5f);
break;		break;
}		}
}		}

if (!Pass::equals(prevpasses, scene->passes)) {		if (!Pass::equals(prevpasses, scene->get_passes())) {
film->tag_passes_update(scene, prevpasses, false);		film->tag_passes_update(scene, prevpasses, false);
film->tag_modified();		film->tag_modified();
}		}
}		}

/* Render Layer */		/* Render Layer */

void BlenderSync::sync_view_layer(BL::SpaceView3D & /b_v3d/, BL::ViewLayer &b_view_layer)		void BlenderSync::sync_view_layer(BL::SpaceView3D & /b_v3d/, BL::ViewLayer &b_view_layer)
{		{
view_layer.name = b_view_layer.name();		view_layer.name = b_view_layer.name();

/* Filter. */		/* Filter. */
view_layer.use_background_shader = b_view_layer.use_sky();		view_layer.use_background_shader = b_view_layer.use_sky();
view_layer.use_background_ao = b_view_layer.use_ao();		view_layer.use_background_ao = b_view_layer.use_ao();
/* Always enable surfaces for baking, otherwise there is nothing to bake to. */		/* Always enable surfaces for baking, otherwise there is nothing to bake to. */
view_layer.use_surfaces = b_view_layer.use_solid() \|\| scene->bake_manager->get_baking();		view_layer.use_surfaces = b_view_layer.use_solid() \|\| scene->get_bake_manager()->get_baking();
view_layer.use_hair = b_view_layer.use_strand();		view_layer.use_hair = b_view_layer.use_strand();
view_layer.use_volumes = b_view_layer.use_volumes();		view_layer.use_volumes = b_view_layer.use_volumes();

/* Material override. */		/* Material override. */
view_layer.material_override = b_view_layer.material_override();		view_layer.material_override = b_view_layer.material_override();

/* Sample override. */		/* Sample override. */
PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");		PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Lines	vector<Pass> BlenderSync::sync_render_passes(BL::RenderLayer &b_rlay,

/* loop over passes */		/* loop over passes */
BL::RenderLayer::passes_iterator b_pass_iter;		BL::RenderLayer::passes_iterator b_pass_iter;

for (b_rlay.passes.begin(b_pass_iter); b_pass_iter != b_rlay.passes.end(); ++b_pass_iter) {		for (b_rlay.passes.begin(b_pass_iter); b_pass_iter != b_rlay.passes.end(); ++b_pass_iter) {
BL::RenderPass b_pass(*b_pass_iter);		BL::RenderPass b_pass(*b_pass_iter);
PassType pass_type = get_pass_type(b_pass);		PassType pass_type = get_pass_type(b_pass);

if (pass_type == PASS_MOTION && scene->integrator->get_motion_blur())		if (pass_type == PASS_MOTION && scene->get_integrator()->get_motion_blur())
continue;		continue;
if (pass_type != PASS_NONE)		if (pass_type != PASS_NONE)
Pass::add(pass_type, passes, b_pass.name().c_str());		Pass::add(pass_type, passes, b_pass.name().c_str());
}		}

PointerRNA crl = RNA_pointer_get(&b_view_layer.ptr, "cycles");		PointerRNA crl = RNA_pointer_get(&b_view_layer.ptr, "cycles");

int denoising_flags = 0;		int denoising_flags = 0;
Show All 9 Lines	((void)0)
MAP_OPTION("denoising_glossy_direct", DENOISING_CLEAN_GLOSSY_DIR);		MAP_OPTION("denoising_glossy_direct", DENOISING_CLEAN_GLOSSY_DIR);
MAP_OPTION("denoising_glossy_indirect", DENOISING_CLEAN_GLOSSY_IND);		MAP_OPTION("denoising_glossy_indirect", DENOISING_CLEAN_GLOSSY_IND);
MAP_OPTION("denoising_transmission_direct", DENOISING_CLEAN_TRANSMISSION_DIR);		MAP_OPTION("denoising_transmission_direct", DENOISING_CLEAN_TRANSMISSION_DIR);
MAP_OPTION("denoising_transmission_indirect", DENOISING_CLEAN_TRANSMISSION_IND);		MAP_OPTION("denoising_transmission_indirect", DENOISING_CLEAN_TRANSMISSION_IND);
#undef MAP_OPTION		#undef MAP_OPTION
}		}
b_engine.add_pass("Noisy Image", 4, "RGBA", b_view_layer.name().c_str());		b_engine.add_pass("Noisy Image", 4, "RGBA", b_view_layer.name().c_str());
}		}
scene->film->set_denoising_flags(denoising_flags);		scene->get_film()->set_denoising_flags(denoising_flags);

if (denoising.store_passes) {		if (denoising.store_passes) {
b_engine.add_pass("Denoising Normal", 3, "XYZ", b_view_layer.name().c_str());		b_engine.add_pass("Denoising Normal", 3, "XYZ", b_view_layer.name().c_str());
b_engine.add_pass("Denoising Albedo", 3, "RGB", b_view_layer.name().c_str());		b_engine.add_pass("Denoising Albedo", 3, "RGB", b_view_layer.name().c_str());
b_engine.add_pass("Denoising Depth", 1, "Z", b_view_layer.name().c_str());		b_engine.add_pass("Denoising Depth", 1, "Z", b_view_layer.name().c_str());
if (denoising.type == DENOISER_NLM) {		if (denoising.type == DENOISER_NLM) {
b_engine.add_pass("Denoising Shadowing", 1, "X", b_view_layer.name().c_str());		b_engine.add_pass("Denoising Shadowing", 1, "X", b_view_layer.name().c_str());
b_engine.add_pass("Denoising Variance", 3, "RGB", b_view_layer.name().c_str());		b_engine.add_pass("Denoising Variance", 3, "RGB", b_view_layer.name().c_str());
b_engine.add_pass("Denoising Intensity", 1, "X", b_view_layer.name().c_str());		b_engine.add_pass("Denoising Intensity", 1, "X", b_view_layer.name().c_str());
}		}

if (scene->film->get_denoising_flags() & DENOISING_CLEAN_ALL_PASSES) {		if (scene->get_film()->get_denoising_flags() & DENOISING_CLEAN_ALL_PASSES) {
b_engine.add_pass("Denoising Clean", 3, "RGB", b_view_layer.name().c_str());		b_engine.add_pass("Denoising Clean", 3, "RGB", b_view_layer.name().c_str());
}		}
}		}

#ifdef __KERNEL_DEBUG__		#ifdef __KERNEL_DEBUG__
if (get_boolean(crl, "pass_debug_bvh_traversed_nodes")) {		if (get_boolean(crl, "pass_debug_bvh_traversed_nodes")) {
b_engine.add_pass("Debug BVH Traversed Nodes", 1, "X", b_view_layer.name().c_str());		b_engine.add_pass("Debug BVH Traversed Nodes", 1, "X", b_view_layer.name().c_str());
Pass::add(PASS_BVH_TRAVERSED_NODES, passes, "Debug BVH Traversed Nodes");		Pass::add(PASS_BVH_TRAVERSED_NODES, passes, "Debug BVH Traversed Nodes");
Show All 25 Lines	#endif
}		}
if (get_boolean(crl, "use_pass_volume_indirect")) {		if (get_boolean(crl, "use_pass_volume_indirect")) {
b_engine.add_pass("VolumeInd", 3, "RGB", b_view_layer.name().c_str());		b_engine.add_pass("VolumeInd", 3, "RGB", b_view_layer.name().c_str());
Pass::add(PASS_VOLUME_INDIRECT, passes, "VolumeInd");		Pass::add(PASS_VOLUME_INDIRECT, passes, "VolumeInd");
}		}

/* Cryptomatte stores two ID/weight pairs per RGBA layer.		/* Cryptomatte stores two ID/weight pairs per RGBA layer.
* User facing parameter is the number of pairs. */		* User facing parameter is the number of pairs. */
		Film *film = scene->get_film();
int crypto_depth = divide_up(min(16, b_view_layer.pass_cryptomatte_depth()), 2);		int crypto_depth = divide_up(min(16, b_view_layer.pass_cryptomatte_depth()), 2);
scene->film->set_cryptomatte_depth(crypto_depth);		film->set_cryptomatte_depth(crypto_depth);
CryptomatteType cryptomatte_passes = CRYPT_NONE;		CryptomatteType cryptomatte_passes = CRYPT_NONE;
if (b_view_layer.use_pass_cryptomatte_object()) {		if (b_view_layer.use_pass_cryptomatte_object()) {
for (int i = 0; i < crypto_depth; i++) {		for (int i = 0; i < crypto_depth; i++) {
string passname = cryptomatte_prefix + string_printf("Object%02d", i);		string passname = cryptomatte_prefix + string_printf("Object%02d", i);
b_engine.add_pass(passname.c_str(), 4, "RGBA", b_view_layer.name().c_str());		b_engine.add_pass(passname.c_str(), 4, "RGBA", b_view_layer.name().c_str());
Pass::add(PASS_CRYPTOMATTE, passes, passname.c_str());		Pass::add(PASS_CRYPTOMATTE, passes, passname.c_str());
}		}
cryptomatte_passes = (CryptomatteType)(cryptomatte_passes \| CRYPT_OBJECT);		cryptomatte_passes = (CryptomatteType)(cryptomatte_passes \| CRYPT_OBJECT);
Show All 12 Lines	for (int i = 0; i < crypto_depth; i++) {
b_engine.add_pass(passname.c_str(), 4, "RGBA", b_view_layer.name().c_str());		b_engine.add_pass(passname.c_str(), 4, "RGBA", b_view_layer.name().c_str());
Pass::add(PASS_CRYPTOMATTE, passes, passname.c_str());		Pass::add(PASS_CRYPTOMATTE, passes, passname.c_str());
}		}
cryptomatte_passes = (CryptomatteType)(cryptomatte_passes \| CRYPT_ASSET);		cryptomatte_passes = (CryptomatteType)(cryptomatte_passes \| CRYPT_ASSET);
}		}
if (b_view_layer.use_pass_cryptomatte_accurate() && cryptomatte_passes != CRYPT_NONE) {		if (b_view_layer.use_pass_cryptomatte_accurate() && cryptomatte_passes != CRYPT_NONE) {
cryptomatte_passes = (CryptomatteType)(cryptomatte_passes \| CRYPT_ACCURATE);		cryptomatte_passes = (CryptomatteType)(cryptomatte_passes \| CRYPT_ACCURATE);
}		}
scene->film->set_cryptomatte_passes(cryptomatte_passes);		film->set_cryptomatte_passes(cryptomatte_passes);

if (adaptive_sampling) {		if (adaptive_sampling) {
Pass::add(PASS_ADAPTIVE_AUX_BUFFER, passes);		Pass::add(PASS_ADAPTIVE_AUX_BUFFER, passes);
if (!get_boolean(crl, "pass_debug_sample_count")) {		if (!get_boolean(crl, "pass_debug_sample_count")) {
Pass::add(PASS_SAMPLE_COUNT, passes);		Pass::add(PASS_SAMPLE_COUNT, passes);
}		}
}		}

RNA_BEGIN (&crl, b_aov, "aovs") {		RNA_BEGIN (&crl, b_aov, "aovs") {
bool is_color = (get_enum(b_aov, "type") == 1);		bool is_color = (get_enum(b_aov, "type") == 1);
string name = get_string(b_aov, "name");		string name = get_string(b_aov, "name");

if (is_color) {		if (is_color) {
b_engine.add_pass(name.c_str(), 4, "RGBA", b_view_layer.name().c_str());		b_engine.add_pass(name.c_str(), 4, "RGBA", b_view_layer.name().c_str());
Pass::add(PASS_AOV_COLOR, passes, name.c_str());		Pass::add(PASS_AOV_COLOR, passes, name.c_str());
}		}
else {		else {
b_engine.add_pass(name.c_str(), 1, "X", b_view_layer.name().c_str());		b_engine.add_pass(name.c_str(), 1, "X", b_view_layer.name().c_str());
Pass::add(PASS_AOV_VALUE, passes, name.c_str());		Pass::add(PASS_AOV_VALUE, passes, name.c_str());
}		}
}		}
RNA_END;		RNA_END;

scene->film->set_denoising_data_pass(denoising.use \|\| denoising.store_passes);		film->set_denoising_data_pass(denoising.use \|\| denoising.store_passes);
scene->film->set_denoising_clean_pass(scene->film->get_denoising_flags() &		film->set_denoising_clean_pass(film->get_denoising_flags() & DENOISING_CLEAN_ALL_PASSES);
DENOISING_CLEAN_ALL_PASSES);		film->set_denoising_prefiltered_pass(denoising.store_passes && denoising.type == DENOISER_NLM);
scene->film->set_denoising_prefiltered_pass(denoising.store_passes &&
denoising.type == DENOISER_NLM);		film->set_pass_alpha_threshold(b_view_layer.pass_alpha_threshold());
		film->tag_passes_update(scene, passes);
scene->film->set_pass_alpha_threshold(b_view_layer.pass_alpha_threshold());		scene->get_integrator()->tag_update(scene);
scene->film->tag_passes_update(scene, passes);
scene->integrator->tag_update(scene);

return passes;		return passes;
}		}

void BlenderSync::free_data_after_sync(BL::Depsgraph &b_depsgraph)		void BlenderSync::free_data_after_sync(BL::Depsgraph &b_depsgraph)
{		{
/* When viewport display is not needed during render we can force some		/* When viewport display is not needed during render we can force some
* caches to be releases from blender side in order to reduce peak memory		* caches to be releases from blender side in order to reduce peak memory
* footprint during synchronization process.		* footprint during synchronization process.
*/		*/
const bool is_interface_locked = b_engine.render() && b_engine.render().use_lock_interface();		const bool is_interface_locked = b_engine.render() && b_engine.render().use_lock_interface();
const bool can_free_caches = (BlenderSession::headless \|\| is_interface_locked) &&		const bool can_free_caches = (BlenderSession::headless \|\| is_interface_locked) &&
/* Baking re-uses the depsgraph multiple times, clearing crashes		/* Baking re-uses the depsgraph multiple times, clearing crashes
* reading un-evaluated mesh data which isn't aligned with the		* reading un-evaluated mesh data which isn't aligned with the
* geometry we're baking, see T71012. */		* geometry we're baking, see T71012. */
!scene->bake_manager->get_baking();		!scene->get_bake_manager()->get_baking();
if (!can_free_caches) {		if (!can_free_caches) {
return;		return;
}		}
/* TODO(sergey): We can actually remove the whole dependency graph,		/* TODO(sergey): We can actually remove the whole dependency graph,
* but that will need some API support first.		* but that will need some API support first.
*/		*/
BL::Depsgraph::objects_iterator b_ob;		BL::Depsgraph::objects_iterator b_ob;
for (b_depsgraph.objects.begin(b_ob); b_ob != b_depsgraph.objects.end(); ++b_ob) {		for (b_depsgraph.objects.begin(b_ob); b_ob != b_depsgraph.objects.end(); ++b_ob) {
▲ Show 20 Lines • Show All 274 Lines • Show Last 20 Lines