Rename any instance of scene layer or render layer in code with view layer
[blender.git] / source / blender / depsgraph / intern / depsgraph_tag.cc
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
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  * The Original Code is Copyright (C) 2013 Blender Foundation.
19  * All rights reserved.
20  *
21  * Original Author: Joshua Leung
22  * Contributor(s): None Yet
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file blender/depsgraph/intern/depsgraph_tag.cc
28  *  \ingroup depsgraph
29  *
30  * Core routines for how the Depsgraph works.
31  */
32
33 #include <stdio.h>
34 #include <cstring>  /* required for memset */
35 #include <queue>
36
37 #include "BLI_utildefines.h"
38 #include "BLI_task.h"
39 #include "BLI_listbase.h"
40
41 extern "C" {
42 #include "DNA_object_types.h"
43 #include "DNA_particle_types.h"
44 #include "DNA_screen_types.h"
45 #include "DNA_windowmanager_types.h"
46
47
48 #include "BKE_idcode.h"
49 #include "BKE_library.h"
50 #include "BKE_main.h"
51 #include "BKE_node.h"
52 #include "BKE_scene.h"
53 #include "BKE_workspace.h"
54
55 #define new new_
56 #include "BKE_screen.h"
57 #undef new
58 } /* extern "C" */
59
60 #include "DEG_depsgraph.h"
61
62 #include "intern/builder/deg_builder.h"
63 #include "intern/eval/deg_eval_flush.h"
64 #include "intern/nodes/deg_node.h"
65 #include "intern/nodes/deg_node_component.h"
66 #include "intern/nodes/deg_node_operation.h"
67
68 #include "intern/depsgraph_intern.h"
69 #include "util/deg_util_foreach.h"
70
71 /* Define this in order to have more strict sanitization of what tagging flags
72  * are used for ID databnlocks. Ideally, we would always want this, but there
73  * are cases in generic modules (like IR remapping) where we don't want to spent
74  * lots of time trying to guess which components are to be updated.
75  */
76 // #define STRICT_COMPONENT_TAGGING
77
78 /* *********************** */
79 /* Update Tagging/Flushing */
80
81 namespace DEG {
82
83 /* Data-Based Tagging ------------------------------- */
84
85 void lib_id_recalc_tag(Main *bmain, ID *id)
86 {
87         id->tag |= LIB_TAG_ID_RECALC;
88         DEG_id_type_tag(bmain, GS(id->name));
89 }
90
91 void lib_id_recalc_data_tag(Main *bmain, ID *id)
92 {
93         id->tag |= LIB_TAG_ID_RECALC_DATA;
94         DEG_id_type_tag(bmain, GS(id->name));
95 }
96
97 namespace {
98
99 void deg_graph_id_tag_update(Main *bmain, Depsgraph *graph, ID *id, int flag);
100
101 void lib_id_recalc_tag_flag(Main *bmain, ID *id, int flag)
102 {
103         /* This bit of code ensures legacy object->recalc flags are still filled in
104          * the same way as it was expected with the old dependency graph.
105          *
106          * This is because some areas like motion paths and likely some other
107          * physics baking process are doing manual scene update on all the frames,
108          * trying to minimize number of updates.
109          *
110          * But this flag will also let us to re-construct entry nodes for update
111          * after relations update and after layer visibility changes.
112          */
113         if (flag) {
114                 ID_Type id_type = GS(id->name);
115                 if (id_type == ID_OB) {
116                         Object *object = (Object *)id;
117                         object->recalc |= (flag & OB_RECALC_ALL);
118                 }
119                 if (flag & OB_RECALC_OB) {
120                         lib_id_recalc_tag(bmain, id);
121                 }
122                 if (flag & (OB_RECALC_DATA | PSYS_RECALC)) {
123                         lib_id_recalc_data_tag(bmain, id);
124                 }
125         }
126         else {
127                 lib_id_recalc_tag(bmain, id);
128         }
129 }
130
131 /* Special tagging  */
132 void id_tag_update_special_zero_flag(Depsgraph *graph, IDDepsNode *id_node)
133 {
134         /* NOTE: Full ID node update for now, need to minimize that i9n the future. */
135         id_node->tag_update(graph);
136 }
137
138 /* Tag corresponding to OB_RECALC_OB. */
139 void id_tag_update_object_transform(Depsgraph *graph, IDDepsNode *id_node)
140 {
141         ComponentDepsNode *transform_comp =
142                 id_node->find_component(DEG_NODE_TYPE_TRANSFORM);
143         if (transform_comp == NULL) {
144 #ifdef STRICT_COMPONENT_TAGGING
145                 DEG_ERROR_PRINTF("ERROR: Unable to find transform component for %s\n",
146                                  id_node->id_orig->name);
147                 BLI_assert(!"This is not supposed to happen!");
148 #endif
149                 return;
150         }
151         transform_comp->tag_update(graph);
152 }
153
154 /* Tag corresponding to OB_RECALC_DATA. */
155 void id_tag_update_object_data(Depsgraph *graph, IDDepsNode *id_node)
156 {
157         const ID_Type id_type = GS(id_node->id_orig->name);
158         ComponentDepsNode *data_comp = NULL;
159         switch (id_type) {
160                 case ID_OB:
161                 {
162                         const Object *object = (Object *)id_node->id_orig;
163                         switch (object->type) {
164                                 case OB_MESH:
165                                 case OB_CURVE:
166                                 case OB_SURF:
167                                 case OB_FONT:
168                                 case OB_MBALL:
169                                         data_comp = id_node->find_component(DEG_NODE_TYPE_GEOMETRY);
170                                         break;
171                                 case OB_ARMATURE:
172                                         data_comp = id_node->find_component(DEG_NODE_TYPE_EVAL_POSE);
173                                         break;
174                                 /* TODO(sergey): More cases here? */
175                         }
176                         break;
177                 }
178                 case ID_ME:
179                         data_comp = id_node->find_component(DEG_NODE_TYPE_GEOMETRY);
180                         break;
181                 case ID_PA:
182                         return;
183                 case ID_LP:
184                         data_comp = id_node->find_component(DEG_NODE_TYPE_PARAMETERS);
185                         break;
186                 default:
187                         break;
188         }
189         if (data_comp == NULL) {
190 #ifdef STRICT_COMPONENT_TAGGING
191                 DEG_ERROR_PRINTF("ERROR: Unable to find data component for %s\n",
192                                  id_node->id_orig->name);
193                 BLI_assert(!"This is not supposed to happen!");
194 #endif
195                 return;
196         }
197         data_comp->tag_update(graph);
198         /* Special legacy compatibility code, tag data ID for update when object
199          * is tagged for data update.
200          */
201         if (id_type == ID_OB) {
202                 Object *object = (Object *)id_node->id_orig;
203                 ID *data_id = (ID *)object->data;
204                 if (data_id != NULL) {
205                         IDDepsNode *data_id_node = graph->find_id_node(data_id);
206                         // BLI_assert(data_id_node != NULL);
207                         /* TODO(sergey): Do we want more granular tags here? */
208                         /* TODO(sergey): Hrm, during some operations it's possible to have
209                          * object node existing but not it's data. For example, when making
210                          * objects local. This is valid situation, but how can we distinguish
211                          * that from someone trying to do stupid things with dependency
212                          * graph?
213                          */
214                         if (data_id_node != NULL) {
215                                 data_id_node->tag_update(graph);
216                         }
217                 }
218         }
219 }
220
221 /* Tag corresponding to OB_RECALC_TIME. */
222 void id_tag_update_object_time(Depsgraph *graph, IDDepsNode *id_node)
223 {
224         ComponentDepsNode *animation_comp =
225                 id_node->find_component(DEG_NODE_TYPE_ANIMATION);
226         if (animation_comp == NULL) {
227                 /* It's not necessarily we've got animation component in cases when
228                  * we are tagging for time updates.
229                  */
230                 return;
231         }
232         animation_comp->tag_update(graph);
233         /* TODO(sergey): More components to tag here? */
234 }
235
236 void id_tag_update_particle(Depsgraph *graph, IDDepsNode *id_node, int tag)
237 {
238         ComponentDepsNode *particle_comp =
239                 id_node->find_component(DEG_NODE_TYPE_PARAMETERS);
240         ParticleSettings *particle_settings = (ParticleSettings *)id_node->id_orig;
241         particle_settings->recalc |= (tag & PSYS_RECALC);
242         if (particle_comp == NULL) {
243 #ifdef STRICT_COMPONENT_TAGGING
244                 DEG_ERROR_PRINTF("ERROR: Unable to find particle component for %s\n",
245                                  id_node->id_orig->name);
246                 BLI_assert(!"This is not supposed to happen!");
247 #endif
248                 return;
249         }
250         particle_comp->tag_update(graph);
251 }
252
253 void id_tag_update_shading(Depsgraph *graph, IDDepsNode *id_node)
254 {
255         ComponentDepsNode *shading_comp;
256         if (GS(id_node->id_orig->name) == ID_NT) {
257                 shading_comp = id_node->find_component(DEG_NODE_TYPE_SHADING_PARAMETERS);
258         }
259         else {
260                 shading_comp = id_node->find_component(DEG_NODE_TYPE_SHADING);
261         }
262         if (shading_comp == NULL) {
263 #ifdef STRICT_COMPONENT_TAGGING
264                 DEG_ERROR_PRINTF("ERROR: Unable to find shading component for %s\n",
265                                  id_node->id_orig->name);
266                 BLI_assert(!"This is not supposed to happen!");
267 #endif
268                 return;
269         }
270         shading_comp->tag_update(graph);
271 }
272
273 /* Tag corresponding to DEG_TAG_COPY_ON_WRITE. */
274 void id_tag_update_copy_on_write(Depsgraph *graph, IDDepsNode *id_node)
275 {
276         if (!DEG_depsgraph_use_copy_on_write()) {
277                 return;
278         }
279         ComponentDepsNode *cow_comp =
280                 id_node->find_component(DEG_NODE_TYPE_COPY_ON_WRITE);
281         OperationDepsNode *cow_node = cow_comp->get_entry_operation();
282         cow_node->tag_update(graph);
283 }
284
285 void id_tag_update_ntree_special(Main *bmain, Depsgraph *graph, ID *id, int flag)
286 {
287         bNodeTree *ntree = NULL;
288         switch (GS(id->name)) {
289                 case ID_MA:
290                         ntree = ((Material *)id)->nodetree;
291                         break;
292                 default:
293                         break;
294         }
295         if (ntree == NULL) {
296                 return;
297         }
298         IDDepsNode *id_node = graph->find_id_node(&ntree->id);
299         if (id_node != NULL) {
300                 deg_graph_id_tag_update(bmain, graph, id_node->id_orig, flag);
301         }
302 }
303
304 void deg_graph_id_tag_update(Main *bmain, Depsgraph *graph, ID *id, int flag)
305 {
306         Depsgraph *deg_graph = reinterpret_cast<DEG::Depsgraph *>(graph);
307         IDDepsNode *id_node = deg_graph->find_id_node(id);
308         /* Make sure legacy flags are all nicely update. */
309         lib_id_recalc_tag_flag(bmain, id, flag);
310         if (id_node == NULL) {
311                 /* Shouldn't happen, but better be sure here. */
312                 return;
313         }
314         /* Tag components based on flags. */
315         if (flag == 0) {
316                 id_tag_update_special_zero_flag(graph, id_node);
317                 id_tag_update_ntree_special(bmain, graph, id, flag);
318                 return;
319         }
320         if (flag & OB_RECALC_OB) {
321                 id_tag_update_object_transform(graph, id_node);
322         }
323         if (flag & OB_RECALC_DATA) {
324                 id_tag_update_object_data(graph, id_node);
325                 if (DEG_depsgraph_use_copy_on_write()) {
326                         if (flag & DEG_TAG_COPY_ON_WRITE) {
327                                 const ID_Type id_type = GS(id_node->id_orig->name);
328                                 if (id_type == ID_OB) {
329                                         Object *object = (Object *)id_node->id_orig;
330                                         ID *ob_data = (ID *)object->data;
331                                         DEG_id_tag_update_ex(bmain, ob_data, flag);
332                                 }
333                         }
334                 }
335         }
336         if (flag & OB_RECALC_TIME) {
337                 id_tag_update_object_time(graph, id_node);
338         }
339         if (flag & PSYS_RECALC) {
340                 id_tag_update_particle(graph, id_node, flag);
341         }
342         if (flag & DEG_TAG_SHADING_UPDATE) {
343                 id_tag_update_shading(graph, id_node);
344         }
345         if (flag & DEG_TAG_COPY_ON_WRITE) {
346                 id_tag_update_copy_on_write(graph, id_node);
347         }
348         id_tag_update_ntree_special(bmain, graph, id, flag);
349 }
350
351 void deg_id_tag_update(Main *bmain, ID *id, int flag)
352 {
353         lib_id_recalc_tag_flag(bmain, id, flag);
354         LINKLIST_FOREACH(Scene *, scene, &bmain->scene) {
355                 LINKLIST_FOREACH(ViewLayer *, view_layer, &scene->view_layers) {
356                         Depsgraph *depsgraph =
357                                 (Depsgraph *)BKE_scene_get_depsgraph(scene,
358                                                                      view_layer,
359                                                                      false);
360                         if (depsgraph != NULL) {
361                                 deg_graph_id_tag_update(bmain, depsgraph, id, flag);
362                         }
363                 }
364         }
365 }
366
367 void deg_graph_on_visible_update(Main *bmain, Depsgraph *graph)
368 {
369         /* Make sure objects are up to date. */
370         foreach (DEG::IDDepsNode *id_node, graph->id_nodes) {
371                 const ID_Type id_type = GS(id_node->id_orig->name);
372                 /* TODO(sergey): Special exception for now. */
373                 if (id_type == ID_MSK) {
374                         deg_graph_id_tag_update(bmain, graph, id_node->id_orig, 0);
375                 }
376                 if (id_type != ID_OB) {
377                         /* Ignore non-object nodes on visibility changes. */
378                         continue;
379                 }
380                 int flag = 0;
381                 /* We only tag components which needs an update. Tagging everything is
382                  * not a good idea because that might reset particles cache (or any
383                  * other type of cache).
384                  *
385                  * TODO(sergey): Need to generalize this somehow.
386                  */
387                 if (id_type == ID_OB) {
388                         flag |= OB_RECALC_OB | OB_RECALC_DATA | DEG_TAG_COPY_ON_WRITE;
389                 }
390                 deg_graph_id_tag_update(bmain, graph, id_node->id_orig, flag);
391         }
392         /* Make sure collection properties are up to date. */
393         for (Scene *scene_iter = graph->scene; scene_iter != NULL; scene_iter = scene_iter->set) {
394                 IDDepsNode *scene_id_node = graph->find_id_node(&scene_iter->id);
395                 BLI_assert(scene_id_node != NULL);
396                 scene_id_node->tag_update(graph);
397         }
398 }
399
400 }  /* namespace */
401
402 }  // namespace DEG
403
404 /* Tag given ID for an update in all the dependency graphs. */
405 void DEG_id_tag_update(ID *id, int flag)
406 {
407         DEG_id_tag_update_ex(G.main, id, flag);
408 }
409
410 void DEG_id_tag_update_ex(Main *bmain, ID *id, int flag)
411 {
412         if (id == NULL) {
413                 /* Ideally should not happen, but old depsgraph allowed this. */
414                 return;
415         }
416         DEG_DEBUG_PRINTF("%s: id=%s flag=%d\n", __func__, id->name, flag);
417         DEG::deg_id_tag_update(bmain, id, flag);
418 }
419
420 void DEG_graph_id_tag_update(struct Main *bmain,
421                              struct Depsgraph *depsgraph,
422                              struct ID *id,
423                              int flag)
424 {
425         DEG::Depsgraph *graph = (DEG::Depsgraph *)depsgraph;
426         DEG::deg_graph_id_tag_update(bmain, graph, id, flag);
427 }
428
429 /* Tag given ID type for update. */
430 void DEG_id_type_tag(Main *bmain, short id_type)
431 {
432         if (id_type == ID_NT) {
433                 /* Stupid workaround so parent datablocks of nested nodetree get looped
434                  * over when we loop over tagged datablock types.
435                  */
436                 DEG_id_type_tag(bmain, ID_MA);
437                 DEG_id_type_tag(bmain, ID_TE);
438                 DEG_id_type_tag(bmain, ID_LA);
439                 DEG_id_type_tag(bmain, ID_WO);
440                 DEG_id_type_tag(bmain, ID_SCE);
441         }
442
443         bmain->id_tag_update[BKE_idcode_to_index(id_type)] = 1;
444 }
445
446 void DEG_graph_flush_update(Main *bmain, Depsgraph *depsgraph)
447 {
448         if (depsgraph == NULL) {
449                 return;
450         }
451         DEG::deg_graph_flush_updates(bmain, (DEG::Depsgraph *)depsgraph);
452 }
453
454 /* Update dependency graph when visible scenes/layers changes. */
455 void DEG_graph_on_visible_update(Main *bmain, Depsgraph *depsgraph)
456 {
457         DEG::Depsgraph *graph = (DEG::Depsgraph *)depsgraph;
458         DEG::deg_graph_on_visible_update(bmain, graph);
459 }
460
461 void DEG_on_visible_update(Main *bmain, const bool UNUSED(do_time))
462 {
463         LINKLIST_FOREACH(Scene *, scene, &bmain->scene) {
464                 LINKLIST_FOREACH(ViewLayer *, view_layer, &scene->view_layers) {
465                         Depsgraph *depsgraph =
466                                 (Depsgraph *)BKE_scene_get_depsgraph(scene,
467                                                                      view_layer,
468                                                                      false);
469                         if (depsgraph != NULL) {
470                                 DEG_graph_on_visible_update(bmain, depsgraph);
471                         }
472                 }
473         }
474 }
475
476 /* Check if something was changed in the database and inform
477  * editors about this.
478  */
479 void DEG_ids_check_recalc(Main *bmain, Scene *scene, bool time)
480 {
481         ListBase *lbarray[MAX_LIBARRAY];
482         int a;
483         bool updated = false;
484
485         /* Loop over all ID types. */
486         a  = set_listbasepointers(bmain, lbarray);
487         while (a--) {
488                 ListBase *lb = lbarray[a];
489                 ID *id = (ID *)lb->first;
490
491                 if (id && bmain->id_tag_update[BKE_idcode_to_index(GS(id->name))]) {
492                         updated = true;
493                         break;
494                 }
495         }
496
497         DEG::deg_editors_scene_update(bmain, scene, (updated || time));
498 }
499
500 void DEG_ids_clear_recalc(Main *bmain)
501 {
502         ListBase *lbarray[MAX_LIBARRAY];
503         bNodeTree *ntree;
504         int a;
505
506         /* TODO(sergey): Re-implement POST_UPDATE_HANDLER_WORKAROUND using entry_tags
507          * and id_tags storage from the new dependency graph.
508          */
509
510         /* Loop over all ID types. */
511         a  = set_listbasepointers(bmain, lbarray);
512         while (a--) {
513                 ListBase *lb = lbarray[a];
514                 ID *id = (ID *)lb->first;
515
516                 if (id && bmain->id_tag_update[BKE_idcode_to_index(GS(id->name))]) {
517                         for (; id; id = (ID *)id->next) {
518                                 id->tag &= ~(LIB_TAG_ID_RECALC | LIB_TAG_ID_RECALC_DATA);
519
520                                 /* Some ID's contain semi-datablock nodetree */
521                                 ntree = ntreeFromID(id);
522                                 if (ntree != NULL) {
523                                         ntree->id.tag &= ~(LIB_TAG_ID_RECALC | LIB_TAG_ID_RECALC_DATA);
524                                 }
525                         }
526                 }
527         }
528
529         memset(bmain->id_tag_update, 0, sizeof(bmain->id_tag_update));
530 }