static bool object_render_hide(BL::Object b_ob, bool top_level, bool parent_hide, bool& hide_triangles) { /* check if we should render or hide particle emitter */ BL::Object::particle_systems_iterator b_psys; bool hair_present = false; bool show_emitter = false; bool hide = false; for(b_ob.particle_systems.begin(b_psys); b_psys != b_ob.particle_systems.end(); ++b_psys) { if((b_psys->settings().render_type() == BL::ParticleSettings::render_type_PATH) && (b_psys->settings().type()==BL::ParticleSettings::type_HAIR)) hair_present = true; if(b_psys->settings().use_render_emitter()) { hide = false; show_emitter = true; } } /* duplicators hidden by default, except dupliframes which duplicate self */ if(b_ob.is_duplicator()) if(top_level || b_ob.dupli_type() != BL::Object::dupli_type_FRAMES) hide = true; /* hide original object for duplis */ BL::Object parent = b_ob.parent(); if(parent && object_render_hide_original(parent.dupli_type())) if(parent_hide) hide = true; hide_triangles = (hair_present && !show_emitter); return hide && !show_emitter; }
Object *BlenderSync::sync_object(BL::Depsgraph &b_depsgraph, BL::ViewLayer &b_view_layer, BL::DepsgraphObjectInstance &b_instance, float motion_time, bool show_self, bool show_particles, BlenderObjectCulling &culling, bool *use_portal) { const bool is_instance = b_instance.is_instance(); BL::Object b_ob = b_instance.object(); BL::Object b_parent = is_instance ? b_instance.parent() : b_instance.object(); BL::Object b_ob_instance = is_instance ? b_instance.instance_object() : b_ob; const bool motion = motion_time != 0.0f; /*const*/ Transform tfm = get_transform(b_ob.matrix_world()); int *persistent_id = NULL; BL::Array<int, OBJECT_PERSISTENT_ID_SIZE> persistent_id_array; if (is_instance) { persistent_id_array = b_instance.persistent_id(); persistent_id = persistent_id_array.data; } /* light is handled separately */ if (!motion && object_is_light(b_ob)) { /* TODO: don't use lights for excluded layers used as mask layer, * when dynamic overrides are back. */ #if 0 if (!((layer_flag & view_layer.holdout_layer) && (layer_flag & view_layer.exclude_layer))) #endif { sync_light(b_parent, persistent_id, b_ob, b_ob_instance, is_instance ? b_instance.random_id() : 0, tfm, use_portal); } return NULL; } /* only interested in object that we can create meshes from */ if (!object_is_mesh(b_ob)) { return NULL; } /* Perform object culling. */ if (culling.test(scene, b_ob, tfm)) { return NULL; } /* Visibility flags for both parent and child. */ PointerRNA cobject = RNA_pointer_get(&b_ob.ptr, "cycles"); bool use_holdout = get_boolean(cobject, "is_holdout") || b_parent.holdout_get(PointerRNA_NULL, b_view_layer); uint visibility = object_ray_visibility(b_ob) & PATH_RAY_ALL_VISIBILITY; if (b_parent.ptr.data != b_ob.ptr.data) { visibility &= object_ray_visibility(b_parent); } /* TODO: make holdout objects on excluded layer invisible for non-camera rays. */ #if 0 if (use_holdout && (layer_flag & view_layer.exclude_layer)) { visibility &= ~(PATH_RAY_ALL_VISIBILITY - PATH_RAY_CAMERA); } #endif /* Clear camera visibility for indirect only objects. */ bool use_indirect_only = b_parent.indirect_only_get(PointerRNA_NULL, b_view_layer); if (use_indirect_only) { visibility &= ~PATH_RAY_CAMERA; } /* Don't export completely invisible objects. */ if (visibility == 0) { return NULL; } /* key to lookup object */ ObjectKey key(b_parent, persistent_id, b_ob_instance); Object *object; /* motion vector case */ if (motion) { object = object_map.find(key); if (object && object->use_motion()) { /* Set transform at matching motion time step. */ int time_index = object->motion_step(motion_time); if (time_index >= 0) { object->motion[time_index] = tfm; } /* mesh deformation */ if (object->mesh) sync_mesh_motion(b_depsgraph, b_ob, object, motion_time); } return object; } /* test if we need to sync */ bool object_updated = false; if (object_map.sync(&object, b_ob, b_parent, key)) object_updated = true; /* mesh sync */ object->mesh = sync_mesh( b_depsgraph, b_ob, b_ob_instance, object_updated, show_self, show_particles); /* special case not tracked by object update flags */ /* holdout */ if (use_holdout != object->use_holdout) { object->use_holdout = use_holdout; scene->object_manager->tag_update(scene); object_updated = true; } if (visibility != object->visibility) { object->visibility = visibility; object_updated = true; } bool is_shadow_catcher = get_boolean(cobject, "is_shadow_catcher"); if (is_shadow_catcher != object->is_shadow_catcher) { object->is_shadow_catcher = is_shadow_catcher; object_updated = true; } /* sync the asset name for Cryptomatte */ BL::Object parent = b_ob.parent(); ustring parent_name; if (parent) { while (parent.parent()) { parent = parent.parent(); } parent_name = parent.name(); } else { parent_name = b_ob.name(); } if (object->asset_name != parent_name) { object->asset_name = parent_name; object_updated = true; } /* object sync * transform comparison should not be needed, but duplis don't work perfect * in the depsgraph and may not signal changes, so this is a workaround */ if (object_updated || (object->mesh && object->mesh->need_update) || tfm != object->tfm) { object->name = b_ob.name().c_str(); object->pass_id = b_ob.pass_index(); object->tfm = tfm; object->motion.clear(); /* motion blur */ Scene::MotionType need_motion = scene->need_motion(); if (need_motion != Scene::MOTION_NONE && object->mesh) { Mesh *mesh = object->mesh; mesh->use_motion_blur = false; mesh->motion_steps = 0; uint motion_steps; if (need_motion == Scene::MOTION_BLUR) { motion_steps = object_motion_steps(b_parent, b_ob); mesh->motion_steps = motion_steps; if (motion_steps && object_use_deform_motion(b_parent, b_ob)) { mesh->use_motion_blur = true; } } else { motion_steps = 3; mesh->motion_steps = motion_steps; } object->motion.clear(); object->motion.resize(motion_steps, transform_empty()); if (motion_steps) { object->motion[motion_steps / 2] = tfm; for (size_t step = 0; step < motion_steps; step++) { motion_times.insert(object->motion_time(step)); } } } /* dupli texture coordinates and random_id */ if (is_instance) { object->dupli_generated = 0.5f * get_float3(b_instance.orco()) - make_float3(0.5f, 0.5f, 0.5f); object->dupli_uv = get_float2(b_instance.uv()); object->random_id = b_instance.random_id(); } else { object->dupli_generated = make_float3(0.0f, 0.0f, 0.0f); object->dupli_uv = make_float2(0.0f, 0.0f); object->random_id = hash_int_2d(hash_string(object->name.c_str()), 0); } object->tag_update(scene); } if (is_instance) { /* Sync possible particle data. */ sync_dupli_particle(b_parent, b_instance, object); } return object; }
static bool object_render_hide_duplis(BL::Object b_ob) { BL::Object parent = b_ob.parent(); return (parent && object_render_hide_original(b_ob.type(), parent.dupli_type())); }