From e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Wed, 17 Apr 2019 06:17:24 +0200 Subject: ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat --- intern/cycles/blender/blender_object.cpp | 1169 +++++++++++++++--------------- 1 file changed, 577 insertions(+), 592 deletions(-) (limited to 'intern/cycles/blender/blender_object.cpp') diff --git a/intern/cycles/blender/blender_object.cpp b/intern/cycles/blender/blender_object.cpp index a296488a14a..095ecd59985 100644 --- a/intern/cycles/blender/blender_object.cpp +++ b/intern/cycles/blender/blender_object.cpp @@ -37,646 +37,631 @@ CCL_NAMESPACE_BEGIN /* Utilities */ -bool BlenderSync::BKE_object_is_modified(BL::Object& b_ob) +bool BlenderSync::BKE_object_is_modified(BL::Object &b_ob) { - /* test if we can instance or if the object is modified */ - if(b_ob.type() == BL::Object::type_META) { - /* multi-user and dupli metaballs are fused, can't instance */ - return true; - } - else if(ccl::BKE_object_is_modified(b_ob, b_scene, preview)) { - /* modifiers */ - return true; - } - else { - /* object level material links */ - BL::Object::material_slots_iterator slot; - for(b_ob.material_slots.begin(slot); slot != b_ob.material_slots.end(); ++slot) - if(slot->link() == BL::MaterialSlot::link_OBJECT) - return true; - } - - return false; + /* test if we can instance or if the object is modified */ + if (b_ob.type() == BL::Object::type_META) { + /* multi-user and dupli metaballs are fused, can't instance */ + return true; + } + else if (ccl::BKE_object_is_modified(b_ob, b_scene, preview)) { + /* modifiers */ + return true; + } + else { + /* object level material links */ + BL::Object::material_slots_iterator slot; + for (b_ob.material_slots.begin(slot); slot != b_ob.material_slots.end(); ++slot) + if (slot->link() == BL::MaterialSlot::link_OBJECT) + return true; + } + + return false; } -bool BlenderSync::object_is_mesh(BL::Object& b_ob) +bool BlenderSync::object_is_mesh(BL::Object &b_ob) { - BL::ID b_ob_data = b_ob.data(); - - if(!b_ob_data) { - return false; - } - - if(b_ob.type() == BL::Object::type_CURVE) { - /* Skip exporting curves without faces, overhead can be - * significant if there are many for path animation. */ - BL::Curve b_curve(b_ob.data()); - - return (b_curve.bevel_object() || - b_curve.extrude() != 0.0f || - b_curve.bevel_depth() != 0.0f || - b_curve.dimensions() == BL::Curve::dimensions_2D || - b_ob.modifiers.length()); - } - else { - return (b_ob_data.is_a(&RNA_Mesh) || - b_ob_data.is_a(&RNA_Curve) || - b_ob_data.is_a(&RNA_MetaBall)); - } + BL::ID b_ob_data = b_ob.data(); + + if (!b_ob_data) { + return false; + } + + if (b_ob.type() == BL::Object::type_CURVE) { + /* Skip exporting curves without faces, overhead can be + * significant if there are many for path animation. */ + BL::Curve b_curve(b_ob.data()); + + return (b_curve.bevel_object() || b_curve.extrude() != 0.0f || b_curve.bevel_depth() != 0.0f || + b_curve.dimensions() == BL::Curve::dimensions_2D || b_ob.modifiers.length()); + } + else { + return (b_ob_data.is_a(&RNA_Mesh) || b_ob_data.is_a(&RNA_Curve) || + b_ob_data.is_a(&RNA_MetaBall)); + } } -bool BlenderSync::object_is_light(BL::Object& b_ob) +bool BlenderSync::object_is_light(BL::Object &b_ob) { - BL::ID b_ob_data = b_ob.data(); + BL::ID b_ob_data = b_ob.data(); - return (b_ob_data && b_ob_data.is_a(&RNA_Light)); + return (b_ob_data && b_ob_data.is_a(&RNA_Light)); } -static uint object_ray_visibility(BL::Object& b_ob) +static uint object_ray_visibility(BL::Object &b_ob) { - PointerRNA cvisibility = RNA_pointer_get(&b_ob.ptr, "cycles_visibility"); - uint flag = 0; + PointerRNA cvisibility = RNA_pointer_get(&b_ob.ptr, "cycles_visibility"); + uint flag = 0; - flag |= get_boolean(cvisibility, "camera")? PATH_RAY_CAMERA: 0; - flag |= get_boolean(cvisibility, "diffuse")? PATH_RAY_DIFFUSE: 0; - flag |= get_boolean(cvisibility, "glossy")? PATH_RAY_GLOSSY: 0; - flag |= get_boolean(cvisibility, "transmission")? PATH_RAY_TRANSMIT: 0; - flag |= get_boolean(cvisibility, "shadow")? PATH_RAY_SHADOW: 0; - flag |= get_boolean(cvisibility, "scatter")? PATH_RAY_VOLUME_SCATTER: 0; + flag |= get_boolean(cvisibility, "camera") ? PATH_RAY_CAMERA : 0; + flag |= get_boolean(cvisibility, "diffuse") ? PATH_RAY_DIFFUSE : 0; + flag |= get_boolean(cvisibility, "glossy") ? PATH_RAY_GLOSSY : 0; + flag |= get_boolean(cvisibility, "transmission") ? PATH_RAY_TRANSMIT : 0; + flag |= get_boolean(cvisibility, "shadow") ? PATH_RAY_SHADOW : 0; + flag |= get_boolean(cvisibility, "scatter") ? PATH_RAY_VOLUME_SCATTER : 0; - return flag; + return flag; } /* Light */ -void BlenderSync::sync_light(BL::Object& b_parent, +void BlenderSync::sync_light(BL::Object &b_parent, int persistent_id[OBJECT_PERSISTENT_ID_SIZE], - BL::Object& b_ob, - BL::Object& b_ob_instance, + BL::Object &b_ob, + BL::Object &b_ob_instance, int random_id, - Transform& tfm, + Transform &tfm, bool *use_portal) { - /* test if we need to sync */ - Light *light; - ObjectKey key(b_parent, persistent_id, b_ob_instance); - - if(!light_map.sync(&light, b_ob, b_parent, key)) { - if(light->is_portal) - *use_portal = true; - return; - } - - BL::Light b_light(b_ob.data()); - - /* type */ - switch(b_light.type()) { - case BL::Light::type_POINT: { - BL::PointLight b_point_light(b_light); - light->size = b_point_light.shadow_soft_size(); - light->type = LIGHT_POINT; - break; - } - case BL::Light::type_SPOT: { - BL::SpotLight b_spot_light(b_light); - light->size = b_spot_light.shadow_soft_size(); - light->type = LIGHT_SPOT; - light->spot_angle = b_spot_light.spot_size(); - light->spot_smooth = b_spot_light.spot_blend(); - break; - } - /* Hemi were removed from 2.8 */ - // case BL::Light::type_HEMI: { - // light->type = LIGHT_DISTANT; - // light->size = 0.0f; - // break; - // } - case BL::Light::type_SUN: { - BL::SunLight b_sun_light(b_light); - light->size = b_sun_light.shadow_soft_size(); - light->type = LIGHT_DISTANT; - break; - } - case BL::Light::type_AREA: { - BL::AreaLight b_area_light(b_light); - light->size = 1.0f; - light->axisu = transform_get_column(&tfm, 0); - light->axisv = transform_get_column(&tfm, 1); - light->sizeu = b_area_light.size(); - switch(b_area_light.shape()) { - case BL::AreaLight::shape_SQUARE: - light->sizev = light->sizeu; - light->round = false; - break; - case BL::AreaLight::shape_RECTANGLE: - light->sizev = b_area_light.size_y(); - light->round = false; - break; - case BL::AreaLight::shape_DISK: - light->sizev = light->sizeu; - light->round = true; - break; - case BL::AreaLight::shape_ELLIPSE: - light->sizev = b_area_light.size_y(); - light->round = true; - break; - } - light->type = LIGHT_AREA; - break; - } - } - - /* location and (inverted!) direction */ - light->co = transform_get_column(&tfm, 3); - light->dir = -transform_get_column(&tfm, 2); - light->tfm = tfm; - - /* shader */ - vector used_shaders; - find_shader(b_light, used_shaders, scene->default_light); - light->shader = used_shaders[0]; - - /* shadow */ - PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles"); - PointerRNA clight = RNA_pointer_get(&b_light.ptr, "cycles"); - light->cast_shadow = get_boolean(clight, "cast_shadow"); - light->use_mis = get_boolean(clight, "use_multiple_importance_sampling"); - - int samples = get_int(clight, "samples"); - if(get_boolean(cscene, "use_square_samples")) - light->samples = samples * samples; - else - light->samples = samples; - - light->max_bounces = get_int(clight, "max_bounces"); - - if(b_ob != b_ob_instance) { - light->random_id = random_id; - } - else { - light->random_id = hash_int_2d(hash_string(b_ob.name().c_str()), 0); - } - - if(light->type == LIGHT_AREA) - light->is_portal = get_boolean(clight, "is_portal"); - else - light->is_portal = false; - - if(light->is_portal) - *use_portal = true; - - /* visibility */ - uint visibility = object_ray_visibility(b_ob); - light->use_diffuse = (visibility & PATH_RAY_DIFFUSE) != 0; - light->use_glossy = (visibility & PATH_RAY_GLOSSY) != 0; - light->use_transmission = (visibility & PATH_RAY_TRANSMIT) != 0; - light->use_scatter = (visibility & PATH_RAY_VOLUME_SCATTER) != 0; - - /* tag */ - light->tag_update(scene); + /* test if we need to sync */ + Light *light; + ObjectKey key(b_parent, persistent_id, b_ob_instance); + + if (!light_map.sync(&light, b_ob, b_parent, key)) { + if (light->is_portal) + *use_portal = true; + return; + } + + BL::Light b_light(b_ob.data()); + + /* type */ + switch (b_light.type()) { + case BL::Light::type_POINT: { + BL::PointLight b_point_light(b_light); + light->size = b_point_light.shadow_soft_size(); + light->type = LIGHT_POINT; + break; + } + case BL::Light::type_SPOT: { + BL::SpotLight b_spot_light(b_light); + light->size = b_spot_light.shadow_soft_size(); + light->type = LIGHT_SPOT; + light->spot_angle = b_spot_light.spot_size(); + light->spot_smooth = b_spot_light.spot_blend(); + break; + } + /* Hemi were removed from 2.8 */ + // case BL::Light::type_HEMI: { + // light->type = LIGHT_DISTANT; + // light->size = 0.0f; + // break; + // } + case BL::Light::type_SUN: { + BL::SunLight b_sun_light(b_light); + light->size = b_sun_light.shadow_soft_size(); + light->type = LIGHT_DISTANT; + break; + } + case BL::Light::type_AREA: { + BL::AreaLight b_area_light(b_light); + light->size = 1.0f; + light->axisu = transform_get_column(&tfm, 0); + light->axisv = transform_get_column(&tfm, 1); + light->sizeu = b_area_light.size(); + switch (b_area_light.shape()) { + case BL::AreaLight::shape_SQUARE: + light->sizev = light->sizeu; + light->round = false; + break; + case BL::AreaLight::shape_RECTANGLE: + light->sizev = b_area_light.size_y(); + light->round = false; + break; + case BL::AreaLight::shape_DISK: + light->sizev = light->sizeu; + light->round = true; + break; + case BL::AreaLight::shape_ELLIPSE: + light->sizev = b_area_light.size_y(); + light->round = true; + break; + } + light->type = LIGHT_AREA; + break; + } + } + + /* location and (inverted!) direction */ + light->co = transform_get_column(&tfm, 3); + light->dir = -transform_get_column(&tfm, 2); + light->tfm = tfm; + + /* shader */ + vector used_shaders; + find_shader(b_light, used_shaders, scene->default_light); + light->shader = used_shaders[0]; + + /* shadow */ + PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles"); + PointerRNA clight = RNA_pointer_get(&b_light.ptr, "cycles"); + light->cast_shadow = get_boolean(clight, "cast_shadow"); + light->use_mis = get_boolean(clight, "use_multiple_importance_sampling"); + + int samples = get_int(clight, "samples"); + if (get_boolean(cscene, "use_square_samples")) + light->samples = samples * samples; + else + light->samples = samples; + + light->max_bounces = get_int(clight, "max_bounces"); + + if (b_ob != b_ob_instance) { + light->random_id = random_id; + } + else { + light->random_id = hash_int_2d(hash_string(b_ob.name().c_str()), 0); + } + + if (light->type == LIGHT_AREA) + light->is_portal = get_boolean(clight, "is_portal"); + else + light->is_portal = false; + + if (light->is_portal) + *use_portal = true; + + /* visibility */ + uint visibility = object_ray_visibility(b_ob); + light->use_diffuse = (visibility & PATH_RAY_DIFFUSE) != 0; + light->use_glossy = (visibility & PATH_RAY_GLOSSY) != 0; + light->use_transmission = (visibility & PATH_RAY_TRANSMIT) != 0; + light->use_scatter = (visibility & PATH_RAY_VOLUME_SCATTER) != 0; + + /* tag */ + light->tag_update(scene); } void BlenderSync::sync_background_light(bool use_portal) { - BL::World b_world = b_scene.world(); - - if(b_world) { - PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles"); - PointerRNA cworld = RNA_pointer_get(&b_world.ptr, "cycles"); - - enum SamplingMethod { - SAMPLING_NONE = 0, - SAMPLING_AUTOMATIC, - SAMPLING_MANUAL, - SAMPLING_NUM - }; - int sampling_method = get_enum(cworld, "sampling_method", SAMPLING_NUM, SAMPLING_AUTOMATIC); - bool sample_as_light = (sampling_method != SAMPLING_NONE); - - if(sample_as_light || use_portal) { - /* test if we need to sync */ - Light *light; - ObjectKey key(b_world, 0, b_world); - - if(light_map.sync(&light, b_world, b_world, key) || - world_recalc || - b_world.ptr.data != world_map) - { - light->type = LIGHT_BACKGROUND; - if(sampling_method == SAMPLING_MANUAL) { - light->map_resolution = get_int(cworld, "sample_map_resolution"); - } - else { - light->map_resolution = 0; - } - light->shader = scene->default_background; - light->use_mis = sample_as_light; - light->max_bounces = get_int(cworld, "max_bounces"); - - int samples = get_int(cworld, "samples"); - if(get_boolean(cscene, "use_square_samples")) - light->samples = samples * samples; - else - light->samples = samples; - - light->tag_update(scene); - light_map.set_recalc(b_world); - } - } - } - - world_map = b_world.ptr.data; - world_recalc = false; + BL::World b_world = b_scene.world(); + + if (b_world) { + PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles"); + PointerRNA cworld = RNA_pointer_get(&b_world.ptr, "cycles"); + + enum SamplingMethod { SAMPLING_NONE = 0, SAMPLING_AUTOMATIC, SAMPLING_MANUAL, SAMPLING_NUM }; + int sampling_method = get_enum(cworld, "sampling_method", SAMPLING_NUM, SAMPLING_AUTOMATIC); + bool sample_as_light = (sampling_method != SAMPLING_NONE); + + if (sample_as_light || use_portal) { + /* test if we need to sync */ + Light *light; + ObjectKey key(b_world, 0, b_world); + + if (light_map.sync(&light, b_world, b_world, key) || world_recalc || + b_world.ptr.data != world_map) { + light->type = LIGHT_BACKGROUND; + if (sampling_method == SAMPLING_MANUAL) { + light->map_resolution = get_int(cworld, "sample_map_resolution"); + } + else { + light->map_resolution = 0; + } + light->shader = scene->default_background; + light->use_mis = sample_as_light; + light->max_bounces = get_int(cworld, "max_bounces"); + + int samples = get_int(cworld, "samples"); + if (get_boolean(cscene, "use_square_samples")) + light->samples = samples * samples; + else + light->samples = samples; + + light->tag_update(scene); + light_map.set_recalc(b_world); + } + } + } + + world_map = b_world.ptr.data; + world_recalc = false; } /* Object */ -Object *BlenderSync::sync_object(BL::Depsgraph& b_depsgraph, - BL::ViewLayer& b_view_layer, - BL::DepsgraphObjectInstance& b_instance, +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, + 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 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. */ + 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 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))) + 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. */ + { + 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); - } + 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; + /* 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; } /* Object Loop */ -void BlenderSync::sync_objects(BL::Depsgraph& b_depsgraph, float motion_time) +void BlenderSync::sync_objects(BL::Depsgraph &b_depsgraph, float motion_time) { - /* layer data */ - bool motion = motion_time != 0.0f; - - if(!motion) { - /* prepare for sync */ - light_map.pre_sync(); - mesh_map.pre_sync(); - object_map.pre_sync(); - particle_system_map.pre_sync(); - motion_times.clear(); - } - else { - mesh_motion_synced.clear(); - } - - /* initialize culling */ - BlenderObjectCulling culling(scene, b_scene); - - /* object loop */ - bool cancel = false; - bool use_portal = false; - - BL::ViewLayer b_view_layer = b_depsgraph.view_layer_eval(); - - BL::Depsgraph::object_instances_iterator b_instance_iter; - for(b_depsgraph.object_instances.begin(b_instance_iter); - b_instance_iter != b_depsgraph.object_instances.end() && !cancel; - ++b_instance_iter) - { - BL::DepsgraphObjectInstance b_instance = *b_instance_iter; - BL::Object b_ob = b_instance.object(); - - /* load per-object culling data */ - culling.init_object(scene, b_ob); - - /* test if object needs to be hidden */ - const bool show_self = b_instance.show_self(); - const bool show_particles = b_instance.show_particles(); - - if(show_self || show_particles) { - /* object itself */ - sync_object(b_depsgraph, - b_view_layer, - b_instance, - motion_time, - show_self, - show_particles, - culling, - &use_portal); - } - - cancel = progress.get_cancel(); - } - - progress.set_sync_status(""); - - if(!cancel && !motion) { - sync_background_light(use_portal); - - /* handle removed data and modified pointers */ - if(light_map.post_sync()) - scene->light_manager->tag_update(scene); - if(mesh_map.post_sync()) - scene->mesh_manager->tag_update(scene); - if(object_map.post_sync()) - scene->object_manager->tag_update(scene); - if(particle_system_map.post_sync()) - scene->particle_system_manager->tag_update(scene); - } - - if(motion) - mesh_motion_synced.clear(); + /* layer data */ + bool motion = motion_time != 0.0f; + + if (!motion) { + /* prepare for sync */ + light_map.pre_sync(); + mesh_map.pre_sync(); + object_map.pre_sync(); + particle_system_map.pre_sync(); + motion_times.clear(); + } + else { + mesh_motion_synced.clear(); + } + + /* initialize culling */ + BlenderObjectCulling culling(scene, b_scene); + + /* object loop */ + bool cancel = false; + bool use_portal = false; + + BL::ViewLayer b_view_layer = b_depsgraph.view_layer_eval(); + + BL::Depsgraph::object_instances_iterator b_instance_iter; + for (b_depsgraph.object_instances.begin(b_instance_iter); + b_instance_iter != b_depsgraph.object_instances.end() && !cancel; + ++b_instance_iter) { + BL::DepsgraphObjectInstance b_instance = *b_instance_iter; + BL::Object b_ob = b_instance.object(); + + /* load per-object culling data */ + culling.init_object(scene, b_ob); + + /* test if object needs to be hidden */ + const bool show_self = b_instance.show_self(); + const bool show_particles = b_instance.show_particles(); + + if (show_self || show_particles) { + /* object itself */ + sync_object(b_depsgraph, + b_view_layer, + b_instance, + motion_time, + show_self, + show_particles, + culling, + &use_portal); + } + + cancel = progress.get_cancel(); + } + + progress.set_sync_status(""); + + if (!cancel && !motion) { + sync_background_light(use_portal); + + /* handle removed data and modified pointers */ + if (light_map.post_sync()) + scene->light_manager->tag_update(scene); + if (mesh_map.post_sync()) + scene->mesh_manager->tag_update(scene); + if (object_map.post_sync()) + scene->object_manager->tag_update(scene); + if (particle_system_map.post_sync()) + scene->particle_system_manager->tag_update(scene); + } + + if (motion) + mesh_motion_synced.clear(); } -void BlenderSync::sync_motion(BL::RenderSettings& b_render, - BL::Depsgraph& b_depsgraph, - BL::Object& b_override, - int width, int height, +void BlenderSync::sync_motion(BL::RenderSettings &b_render, + BL::Depsgraph &b_depsgraph, + BL::Object &b_override, + int width, + int height, void **python_thread_state) { - if(scene->need_motion() == Scene::MOTION_NONE) - return; - - /* get camera object here to deal with camera switch */ - BL::Object b_cam = b_scene.camera(); - if(b_override) - b_cam = b_override; - - Camera prevcam = *(scene->camera); - - int frame_center = b_scene.frame_current(); - float subframe_center = b_scene.frame_subframe(); - float frame_center_delta = 0.0f; - - if(scene->need_motion() != Scene::MOTION_PASS && - scene->camera->motion_position != Camera::MOTION_POSITION_CENTER) - { - float shuttertime = scene->camera->shuttertime; - if(scene->camera->motion_position == Camera::MOTION_POSITION_END) { - frame_center_delta = -shuttertime * 0.5f; - } - else { - assert(scene->camera->motion_position == Camera::MOTION_POSITION_START); - frame_center_delta = shuttertime * 0.5f; - } - - float time = frame_center + subframe_center + frame_center_delta; - int frame = (int)floorf(time); - float subframe = time - frame; - python_thread_state_restore(python_thread_state); - b_engine.frame_set(frame, subframe); - python_thread_state_save(python_thread_state); - sync_camera_motion(b_render, b_cam, width, height, 0.0f); - sync_objects(b_depsgraph, 0.0f); - } - - /* always sample these times for camera motion */ - motion_times.insert(-1.0f); - motion_times.insert(1.0f); - - /* note iteration over motion_times set happens in sorted order */ - foreach(float relative_time, motion_times) { - /* center time is already handled. */ - if(relative_time == 0.0f) { - continue; - } - - VLOG(1) << "Synchronizing motion for the relative time " - << relative_time << "."; - - /* fixed shutter time to get previous and next frame for motion pass */ - float shuttertime = scene->motion_shutter_time(); - - /* compute frame and subframe time */ - float time = frame_center + subframe_center + frame_center_delta + relative_time * shuttertime * 0.5f; - int frame = (int)floorf(time); - float subframe = time - frame; - - /* change frame */ - python_thread_state_restore(python_thread_state); - b_engine.frame_set(frame, subframe); - python_thread_state_save(python_thread_state); - - /* sync camera, only supports two times at the moment */ - if(relative_time == -1.0f || relative_time == 1.0f) { - sync_camera_motion(b_render, - b_cam, - width, height, - relative_time); - } - - /* sync object */ - sync_objects(b_depsgraph, relative_time); - } - - /* we need to set the python thread state again because this - * function assumes it is being executed from python and will - * try to save the thread state */ - python_thread_state_restore(python_thread_state); - b_engine.frame_set(frame_center, subframe_center); - python_thread_state_save(python_thread_state); - - /* tag camera for motion update */ - if(scene->camera->motion_modified(prevcam)) - scene->camera->tag_update(); + if (scene->need_motion() == Scene::MOTION_NONE) + return; + + /* get camera object here to deal with camera switch */ + BL::Object b_cam = b_scene.camera(); + if (b_override) + b_cam = b_override; + + Camera prevcam = *(scene->camera); + + int frame_center = b_scene.frame_current(); + float subframe_center = b_scene.frame_subframe(); + float frame_center_delta = 0.0f; + + if (scene->need_motion() != Scene::MOTION_PASS && + scene->camera->motion_position != Camera::MOTION_POSITION_CENTER) { + float shuttertime = scene->camera->shuttertime; + if (scene->camera->motion_position == Camera::MOTION_POSITION_END) { + frame_center_delta = -shuttertime * 0.5f; + } + else { + assert(scene->camera->motion_position == Camera::MOTION_POSITION_START); + frame_center_delta = shuttertime * 0.5f; + } + + float time = frame_center + subframe_center + frame_center_delta; + int frame = (int)floorf(time); + float subframe = time - frame; + python_thread_state_restore(python_thread_state); + b_engine.frame_set(frame, subframe); + python_thread_state_save(python_thread_state); + sync_camera_motion(b_render, b_cam, width, height, 0.0f); + sync_objects(b_depsgraph, 0.0f); + } + + /* always sample these times for camera motion */ + motion_times.insert(-1.0f); + motion_times.insert(1.0f); + + /* note iteration over motion_times set happens in sorted order */ + foreach (float relative_time, motion_times) { + /* center time is already handled. */ + if (relative_time == 0.0f) { + continue; + } + + VLOG(1) << "Synchronizing motion for the relative time " << relative_time << "."; + + /* fixed shutter time to get previous and next frame for motion pass */ + float shuttertime = scene->motion_shutter_time(); + + /* compute frame and subframe time */ + float time = frame_center + subframe_center + frame_center_delta + + relative_time * shuttertime * 0.5f; + int frame = (int)floorf(time); + float subframe = time - frame; + + /* change frame */ + python_thread_state_restore(python_thread_state); + b_engine.frame_set(frame, subframe); + python_thread_state_save(python_thread_state); + + /* sync camera, only supports two times at the moment */ + if (relative_time == -1.0f || relative_time == 1.0f) { + sync_camera_motion(b_render, b_cam, width, height, relative_time); + } + + /* sync object */ + sync_objects(b_depsgraph, relative_time); + } + + /* we need to set the python thread state again because this + * function assumes it is being executed from python and will + * try to save the thread state */ + python_thread_state_restore(python_thread_state); + b_engine.frame_set(frame_center, subframe_center); + python_thread_state_save(python_thread_state); + + /* tag camera for motion update */ + if (scene->camera->motion_modified(prevcam)) + scene->camera->tag_update(); } CCL_NAMESPACE_END -- cgit v1.2.3