intern/cycles/blender/blender_sync.cpp

   1 /*
   2  * Copyright 2011, Blender Foundation.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  */
  18
  19 #include "background.h"
  20 #include "film.h"
  21 #include "../render/filter.h"
  22 #include "graph.h"
  23 #include "integrator.h"
  24 #include "light.h"
  25 #include "mesh.h"
  26 #include "nodes.h"
  27 #include "object.h"
  28 #include "scene.h"
  29 #include "shader.h"
  30
  31 #include "device.h"
  32
  33 #include "blender_sync.h"
  34 #include "blender_util.h"
  35
  36 #include "util_debug.h"
  37 #include "util_foreach.h"
  38
  39 CCL_NAMESPACE_BEGIN
  40
  41 /* Constructor */
  42
  43 BlenderSync::BlenderSync(BL::BlendData b_data_, BL::Scene b_scene_, Scene *scene_, bool preview_)
  44 : b_data(b_data_), b_scene(b_scene_),
  45   shader_map(&scene_->shaders),
  46   object_map(&scene_->objects),
  47   mesh_map(&scene_->meshes),
  48   light_map(&scene_->lights),
  49   particle_system_map(&scene_->particle_systems),
  50   world_map(NULL),
  51   world_recalc(false),
  52   experimental(false)
  53 {
  54         scene = scene_;
  55         preview = preview_;
  56 }
  57
  58 BlenderSync::~BlenderSync()
  59 {
  60 }
  61
  62 /* Sync */
  63
  64 bool BlenderSync::sync_recalc()
  65 {
  66         /* sync recalc flags from blender to cycles. actual update is done separate,
  67          * so we can do it later on if doing it immediate is not suitable */
  68
  69         BL::BlendData::materials_iterator b_mat;
  70
  71         for(b_data.materials.begin(b_mat); b_mat != b_data.materials.end(); ++b_mat)
  72                 if(b_mat->is_updated() || (b_mat->node_tree() && b_mat->node_tree().is_updated()))
  73                         shader_map.set_recalc(*b_mat);
  74
  75         BL::BlendData::lamps_iterator b_lamp;
  76
  77         for(b_data.lamps.begin(b_lamp); b_lamp != b_data.lamps.end(); ++b_lamp)
  78                 if(b_lamp->is_updated() || (b_lamp->node_tree() && b_lamp->node_tree().is_updated()))
  79                         shader_map.set_recalc(*b_lamp);
  80
  81         BL::BlendData::objects_iterator b_ob;
  82
  83         for(b_data.objects.begin(b_ob); b_ob != b_data.objects.end(); ++b_ob) {
  84                 if(b_ob->is_updated()) {
  85                         object_map.set_recalc(*b_ob);
  86                         light_map.set_recalc(*b_ob);
  87                 }
  88
  89                 if(object_is_mesh(*b_ob)) {
  90                         if(b_ob->is_updated_data() || b_ob->data().is_updated()) {
  91                                 BL::ID key = BKE_object_is_modified(*b_ob)? *b_ob: b_ob->data();
  92                                 mesh_map.set_recalc(key);
  93                         }
  94                 }
  95                 else if(object_is_light(*b_ob)) {
  96                         if(b_ob->is_updated_data() || b_ob->data().is_updated())
  97                                 light_map.set_recalc(*b_ob);
  98                 }
  99
 100                 if(b_ob->is_updated_data()) {
 101                         BL::Object::particle_systems_iterator b_psys;
 102                         for (b_ob->particle_systems.begin(b_psys); b_psys != b_ob->particle_systems.end(); ++b_psys)
 103                                 particle_system_map.set_recalc(*b_ob);
 104                 }
 105         }
 106
 107         BL::BlendData::meshes_iterator b_mesh;
 108
 109         for(b_data.meshes.begin(b_mesh); b_mesh != b_data.meshes.end(); ++b_mesh)
 110                 if(b_mesh->is_updated())
 111                         mesh_map.set_recalc(*b_mesh);
 112
 113         BL::BlendData::worlds_iterator b_world;
 114
 115         for(b_data.worlds.begin(b_world); b_world != b_data.worlds.end(); ++b_world) {
 116                 if(world_map == b_world->ptr.data &&
 117                    (b_world->is_updated() || (b_world->node_tree() && b_world->node_tree().is_updated())))
 118                 {
 119                         world_recalc = true;
 120                 }
 121         }
 122
 123         bool recalc =
 124                 shader_map.has_recalc() ||
 125                 object_map.has_recalc() ||
 126                 light_map.has_recalc() ||
 127                 mesh_map.has_recalc() ||
 128                 particle_system_map.has_recalc() ||
 129                 BlendDataObjects_is_updated_get(&b_data.ptr) ||
 130                 world_recalc;
 131
 132         return recalc;
 133 }
 134
 135 void BlenderSync::sync_data(BL::SpaceView3D b_v3d, BL::Object b_override, const char *layer)
 136 {
 137         sync_render_layers(b_v3d, layer);
 138         sync_integrator();
 139         sync_film();
 140         sync_shaders();
 141         sync_objects(b_v3d);
 142         sync_particle_systems();
 143         sync_motion(b_v3d, b_override);
 144 }
 145
 146 /* Integrator */
 147
 148 void BlenderSync::sync_integrator()
 149 {
 150         PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
 151
 152         experimental = (RNA_enum_get(&cscene, "feature_set") != 0);
 153
 154         Integrator *integrator = scene->integrator;
 155         Integrator previntegrator = *integrator;
 156
 157         integrator->min_bounce = get_int(cscene, "min_bounces");
 158         integrator->max_bounce = get_int(cscene, "max_bounces");
 159
 160         integrator->max_diffuse_bounce = get_int(cscene, "diffuse_bounces");
 161         integrator->max_glossy_bounce = get_int(cscene, "glossy_bounces");
 162         integrator->max_transmission_bounce = get_int(cscene, "transmission_bounces");
 163
 164         integrator->transparent_max_bounce = get_int(cscene, "transparent_max_bounces");
 165         integrator->transparent_min_bounce = get_int(cscene, "transparent_min_bounces");
 166         integrator->transparent_shadows = get_boolean(cscene, "use_transparent_shadows");
 167
 168         integrator->no_caustics = get_boolean(cscene, "no_caustics");
 169         integrator->filter_glossy = get_float(cscene, "blur_glossy");
 170
 171         integrator->seed = get_int(cscene, "seed");
 172
 173         integrator->layer_flag = render_layer.layer;
 174
 175         integrator->sample_clamp = get_float(cscene, "sample_clamp");
 176 #ifdef __MOTION__
 177         integrator->motion_blur = (!preview && r.use_motion_blur());
 178 #endif
 179
 180         integrator->diffuse_samples = get_int(cscene, "diffuse_samples");
 181         integrator->glossy_samples = get_int(cscene, "glossy_samples");
 182         integrator->transmission_samples = get_int(cscene, "transmission_samples");
 183         integrator->ao_samples = get_int(cscene, "ao_samples");
 184         integrator->mesh_light_samples = get_int(cscene, "mesh_light_samples");
 185         integrator->progressive = get_boolean(cscene, "progressive");
 186
 187         if(integrator->modified(previntegrator))
 188                 integrator->tag_update(scene);
 189 }
 190
 191 /* Film */
 192
 193 void BlenderSync::sync_film()
 194 {
 195         PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
 196
 197         Film *film = scene->film;
 198         Film prevfilm = *film;
 199
 200         film->exposure = get_float(cscene, "film_exposure");
 201
 202         if(film->modified(prevfilm))
 203                 film->tag_update(scene);
 204
 205         Filter *filter = scene->filter;
 206         Filter prevfilter = *filter;
 207
 208         filter->filter_type = (FilterType)RNA_enum_get(&cscene, "filter_type");
 209         filter->filter_width = (filter->filter_type == FILTER_BOX)? 1.0f: get_float(cscene, "filter_width");
 210
 211         if(filter->modified(prevfilter))
 212                 filter->tag_update(scene);
 213 }
 214
 215 /* Render Layer */
 216
 217 void BlenderSync::sync_render_layers(BL::SpaceView3D b_v3d, const char *layer)
 218 {
 219         string layername;
 220
 221         /* 3d view */
 222         if(b_v3d) {
 223                 PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
 224
 225                 if(RNA_boolean_get(&cscene, "preview_active_layer")) {
 226                         BL::RenderLayers layers(b_scene.render().ptr);
 227                         layername = layers.active().name();
 228                         layer = layername.c_str();
 229                 }
 230                 else {
 231                         render_layer.use_localview = (b_v3d.local_view() ? true : false);
 232                         render_layer.scene_layer = get_layer(b_v3d.layers(), b_v3d.layers_local_view());
 233                         CYCLES_LOCAL_LAYER_HACK(render_layer.use_localview, render_layer.scene_layer);
 234                         render_layer.layer = render_layer.scene_layer;
 235                         render_layer.holdout_layer = 0;
 236                         render_layer.material_override = PointerRNA_NULL;
 237                         render_layer.use_background = true;
 238                         render_layer.use_viewport_visibility = true;
 239                         render_layer.samples = 0;
 240                         return;
 241                 }
 242         }
 243
 244         /* render layer */
 245         BL::RenderSettings r = b_scene.render();
 246         BL::RenderSettings::layers_iterator b_rlay;
 247         bool first_layer = true;
 248
 249         for(r.layers.begin(b_rlay); b_rlay != r.layers.end(); ++b_rlay) {
 250                 if((!layer && first_layer) || (layer && b_rlay->name() == layer)) {
 251                         render_layer.name = b_rlay->name();
 252                         render_layer.scene_layer = get_layer(b_scene.layers()) & ~get_layer(b_rlay->layers_exclude());
 253                         render_layer.layer = get_layer(b_rlay->layers());
 254                         render_layer.holdout_layer = get_layer(b_rlay->layers_zmask());
 255                         render_layer.layer |= render_layer.holdout_layer;
 256                         render_layer.material_override = b_rlay->material_override();
 257                         render_layer.use_background = b_rlay->use_sky();
 258                         render_layer.use_viewport_visibility = false;
 259                         render_layer.use_localview = false;
 260                         render_layer.samples = b_rlay->samples();
 261                 }
 262
 263                 first_layer = false;
 264         }
 265 }
 266
 267 /* Scene Parameters */
 268
 269 SceneParams BlenderSync::get_scene_params(BL::Scene b_scene, bool background)
 270 {
 271         SceneParams params;
 272         PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
 273         int shadingsystem = RNA_enum_get(&cscene, "shading_system");
 274
 275         if(shadingsystem == 0)
 276                 params.shadingsystem = SceneParams::SVM;
 277         else if(shadingsystem == 1)
 278                 params.shadingsystem = SceneParams::OSL;
 279
 280         if(background)
 281                 params.bvh_type = SceneParams::BVH_STATIC;
 282         else
 283                 params.bvh_type = (SceneParams::BVHType)RNA_enum_get(&cscene, "debug_bvh_type");
 284
 285         params.use_bvh_spatial_split = RNA_boolean_get(&cscene, "debug_use_spatial_splits");
 286         params.use_bvh_cache = (background)? RNA_boolean_get(&cscene, "use_cache"): false;
 287
 288         return params;
 289 }
 290
 291 /* Session Parameters */
 292
 293 bool BlenderSync::get_session_pause(BL::Scene b_scene, bool background)
 294 {
 295         PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
 296         return (background)? false: get_boolean(cscene, "preview_pause");
 297 }
 298
 299 SessionParams BlenderSync::get_session_params(BL::UserPreferences b_userpref, BL::Scene b_scene, bool background)
 300 {
 301         SessionParams params;
 302         PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
 303
 304         /* feature set */
 305         params.experimental = (RNA_enum_get(&cscene, "feature_set") != 0);
 306
 307         /* device type */
 308         vector<DeviceInfo>& devices = Device::available_devices();
 309
 310         /* device default CPU */
 311         params.device = devices[0];
 312
 313         if(RNA_enum_get(&cscene, "device") != 0) {
 314                 /* find GPU device with given id */
 315                 PointerRNA systemptr = b_userpref.system().ptr;
 316                 PropertyRNA *deviceprop = RNA_struct_find_property(&systemptr, "compute_device");
 317                 int device_id = b_userpref.system().compute_device();
 318
 319                 const char *id;
 320
 321                 if(RNA_property_enum_identifier(NULL, &systemptr, deviceprop, device_id, &id)) {
 322                         foreach(DeviceInfo& info, devices)
 323                                 if(info.id == id)
 324                                         params.device = info;
 325                 }
 326         }
 327
 328         /* Background */
 329         params.background = background;
 330
 331         /* samples */
 332         if(get_boolean(cscene, "progressive")) {
 333                 if(background) {
 334                         params.samples = get_int(cscene, "samples");
 335                 }
 336                 else {
 337                         params.samples = get_int(cscene, "preview_samples");
 338                         if(params.samples == 0)
 339                                 params.samples = INT_MAX;
 340                 }
 341         }
 342         else {
 343                 if(background) {
 344                         params.samples = get_int(cscene, "aa_samples");
 345                 }
 346                 else {
 347                         params.samples = get_int(cscene, "preview_aa_samples");
 348                         if(params.samples == 0)
 349                                 params.samples = INT_MAX;
 350                 }
 351         }
 352
 353         /* other parameters */
 354         params.threads = b_scene.render().threads();
 355         params.tile_size = get_int(cscene, "debug_tile_size");
 356         params.min_size = get_int(cscene, "debug_min_size");
 357         params.cancel_timeout = get_float(cscene, "debug_cancel_timeout");
 358         params.reset_timeout = get_float(cscene, "debug_reset_timeout");
 359         params.text_timeout = get_float(cscene, "debug_text_timeout");
 360
 361         if(background) {
 362                 params.progressive = true;
 363                 params.min_size = INT_MAX;
 364         }
 365         else
 366                 params.progressive = true;
 367
 368         /* todo: multi device only works with single tiles now */
 369         if(params.device.type == DEVICE_MULTI)
 370                 params.tile_size = INT_MAX;
 371
 372         return params;
 373 }
 374
 375 CCL_NAMESPACE_END
 376