svn merge ^/trunk/blender -r43934:43976
[blender.git] / 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   world_map(NULL),
50   world_recalc(false),
51   experimental(false),
52   active_layer(0)
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 = 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
101         BL::BlendData::meshes_iterator b_mesh;
102
103         for(b_data.meshes.begin(b_mesh); b_mesh != b_data.meshes.end(); ++b_mesh)
104                 if(b_mesh->is_updated())
105                         mesh_map.set_recalc(*b_mesh);
106
107         BL::BlendData::worlds_iterator b_world;
108
109         for(b_data.worlds.begin(b_world); b_world != b_data.worlds.end(); ++b_world)
110                 if(world_map == b_world->ptr.data &&
111                         (b_world->is_updated() || (b_world->node_tree() && b_world->node_tree().is_updated())))
112                         world_recalc = true;
113
114         bool recalc =
115                 shader_map.has_recalc() ||
116                 object_map.has_recalc() ||
117                 light_map.has_recalc() ||
118                 mesh_map.has_recalc() ||
119                 BlendDataObjects_is_updated_get(&b_data.ptr) ||
120                 world_recalc;
121
122         return recalc;
123 }
124
125 void BlenderSync::sync_data(BL::SpaceView3D b_v3d, const char *layer)
126 {
127         sync_render_layers(b_v3d);
128         sync_integrator(layer);
129         sync_film();
130         sync_shaders();
131         sync_objects(b_v3d);
132 }
133
134 /* Integrator */
135
136 void BlenderSync::sync_integrator(const char *layer)
137 {
138         PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
139
140         experimental = (RNA_enum_get(&cscene, "feature_set") != 0);
141
142         Integrator *integrator = scene->integrator;
143         Integrator previntegrator = *integrator;
144
145         integrator->min_bounce = get_int(cscene, "min_bounces");
146         integrator->max_bounce = get_int(cscene, "max_bounces");
147
148         integrator->max_diffuse_bounce = get_int(cscene, "diffuse_bounces");
149         integrator->max_glossy_bounce = get_int(cscene, "glossy_bounces");
150         integrator->max_transmission_bounce = get_int(cscene, "transmission_bounces");
151
152         integrator->transparent_max_bounce = get_int(cscene, "transparent_max_bounces");
153         integrator->transparent_min_bounce = get_int(cscene, "transparent_min_bounces");
154         integrator->transparent_shadows = get_boolean(cscene, "use_transparent_shadows");
155
156         integrator->no_caustics = get_boolean(cscene, "no_caustics");
157         integrator->seed = get_int(cscene, "seed");
158
159         /* render layer */
160         int active_layer = 0;
161
162         if(layer) {
163                 for(int i = 0; i < render_layers.size(); i++) {
164                         if(render_layers[i].name == layer) {
165                                 active_layer = i;
166                                 break;
167                         }
168                 }
169         }
170
171         integrator->layer_flag = render_layers[active_layer].layer;
172
173         if(integrator->modified(previntegrator))
174                 integrator->tag_update(scene);
175 }
176
177 /* Film */
178
179 void BlenderSync::sync_film()
180 {
181         PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
182
183         Film *film = scene->film;
184         Film prevfilm = *film;
185
186         film->exposure = get_float(cscene, "film_exposure");
187
188         if(film->modified(prevfilm))
189                 film->tag_update(scene);
190
191         Filter *filter = scene->filter;
192         Filter prevfilter = *filter;
193
194         filter->filter_type = (FilterType)RNA_enum_get(&cscene, "filter_type");
195         filter->filter_width = (filter->filter_type == FILTER_BOX)? 1.0f: get_float(cscene, "filter_width");
196
197         if(filter->modified(prevfilter))
198                 filter->tag_update(scene);
199 }
200
201 /* Render Layer */
202
203 void BlenderSync::sync_render_layers(BL::SpaceView3D b_v3d)
204 {
205         render_layers.clear();
206
207         if(b_v3d) {
208                 RenderLayerInfo rlay;
209
210                 rlay.scene_layer = get_layer(b_v3d.layers());
211                 rlay.layer = rlay.scene_layer;
212                 rlay.material_override = PointerRNA_NULL;
213
214                 render_layers.push_back(rlay);
215         }
216         else {
217                 BL::RenderSettings r = b_scene.render();
218                 BL::RenderSettings::layers_iterator b_rlay;
219
220                 for(r.layers.begin(b_rlay); b_rlay != r.layers.end(); ++b_rlay) {
221                         /* single layer for now */
222                         RenderLayerInfo rlay;
223
224                         rlay.name = b_rlay->name();
225                         rlay.scene_layer = get_layer(b_scene.layers());
226                         rlay.layer = get_layer(b_rlay->layers());
227                         rlay.material_override = b_rlay->material_override();
228
229                         render_layers.push_back(rlay);
230                 }
231         }
232 }
233
234 /* Scene Parameters */
235
236 SceneParams BlenderSync::get_scene_params(BL::Scene b_scene, bool background)
237 {
238         SceneParams params;
239         PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
240         int shadingsystem = RNA_enum_get(&cscene, "shading_system");
241
242         if(shadingsystem == 0)
243                 params.shadingsystem = SceneParams::SVM;
244         else if(shadingsystem == 1)
245                 params.shadingsystem = SceneParams::OSL;
246         
247         if(background)
248                 params.bvh_type = SceneParams::BVH_STATIC;
249         else
250                 params.bvh_type = (SceneParams::BVHType)RNA_enum_get(&cscene, "debug_bvh_type");
251
252         params.use_bvh_spatial_split = RNA_boolean_get(&cscene, "debug_use_spatial_splits");
253         params.use_bvh_cache = (background)? RNA_boolean_get(&cscene, "use_cache"): false;
254
255         return params;
256 }
257
258 /* Session Parameters */
259
260 bool BlenderSync::get_session_pause(BL::Scene b_scene, bool background)
261 {
262         PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
263         return (background)? false: get_boolean(cscene, "preview_pause");
264 }
265
266 SessionParams BlenderSync::get_session_params(BL::UserPreferences b_userpref, BL::Scene b_scene, bool background)
267 {
268         SessionParams params;
269         PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
270
271         /* feature set */
272         params.experimental = (RNA_enum_get(&cscene, "feature_set") != 0);
273
274         /* device type */
275         vector<DeviceInfo>& devices = Device::available_devices();
276         
277         /* device default CPU */
278         params.device = devices[0];
279
280         if(RNA_enum_get(&cscene, "device") != 0) {
281                 /* find GPU device with given id */
282                 PointerRNA systemptr = b_userpref.system().ptr;
283                 PropertyRNA *deviceprop = RNA_struct_find_property(&systemptr, "compute_device");
284                 int device_id = b_userpref.system().compute_device();
285
286                 const char *id;
287
288                 if(RNA_property_enum_identifier(NULL, &systemptr, deviceprop, device_id, &id)) {
289                         foreach(DeviceInfo& info, devices)
290                                 if(info.id == id)
291                                         params.device = info;
292                 }
293         }
294
295         /* Background */
296         params.background = background;
297                         
298         /* samples */
299         if(background) {
300                 params.samples = get_int(cscene, "samples");
301         }
302         else {
303                 params.samples = get_int(cscene, "preview_samples");
304                 if(params.samples == 0)
305                         params.samples = INT_MAX;
306         }
307
308         /* other parameters */
309         params.threads = b_scene.render().threads();
310         params.tile_size = get_int(cscene, "debug_tile_size");
311         params.min_size = get_int(cscene, "debug_min_size");
312         params.cancel_timeout = get_float(cscene, "debug_cancel_timeout");
313         params.reset_timeout = get_float(cscene, "debug_reset_timeout");
314         params.text_timeout = get_float(cscene, "debug_text_timeout");
315
316         if(background) {
317                 params.progressive = true;
318                 params.min_size = INT_MAX;
319         }
320         else
321                 params.progressive = true;
322         
323         /* todo: multi device only works with single tiles now */
324         if(params.device.type == DEVICE_MULTI)
325                 params.tile_size = INT_MAX;
326
327         return params;
328 }
329
330 CCL_NAMESPACE_END
331