Merge branch 'master' into blender2.8
[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                 if (flag & OB_RECALC_OB) {
115                         lib_id_recalc_tag(bmain, id);
116                 }
117                 if (flag & (OB_RECALC_DATA | PSYS_RECALC)) {
118                         lib_id_recalc_data_tag(bmain, id);
119                 }
120         }
121         else {
122                 lib_id_recalc_tag(bmain, id);
123         }
124 }
125
126 /* Special tagging  */
127 void id_tag_update_special_zero_flag(Depsgraph *graph, IDDepsNode *id_node)
128 {
129         /* NOTE: Full ID node update for now, need to minimize that i9n the future. */
130         id_node->tag_update(graph);
131 }
132
133 /* Tag corresponding to OB_RECALC_OB. */
134 void id_tag_update_object_transform(Depsgraph *graph, IDDepsNode *id_node)
135 {
136         ComponentDepsNode *transform_comp =
137                 id_node->find_component(DEG_NODE_TYPE_TRANSFORM);
138         if (transform_comp == NULL) {
139 #ifdef STRICT_COMPONENT_TAGGING
140                 DEG_ERROR_PRINTF("ERROR: Unable to find transform component for %s\n",
141                                  id_node->id_orig->name);
142                 BLI_assert(!"This is not supposed to happen!");
143 #endif
144                 return;
145         }
146         transform_comp->tag_update(graph);
147 }
148
149 /* Tag corresponding to OB_RECALC_DATA. */
150 void id_tag_update_object_data(Depsgraph *graph, IDDepsNode *id_node)
151 {
152         const ID_Type id_type = GS(id_node->id_orig->name);
153         ComponentDepsNode *data_comp = NULL;
154         switch (id_type) {
155                 case ID_OB:
156                 {
157                         const Object *object = (Object *)id_node->id_orig;
158                         switch (object->type) {
159                                 case OB_MESH:
160                                 case OB_CURVE:
161                                 case OB_SURF:
162                                 case OB_FONT:
163                                 case OB_MBALL:
164                                         data_comp = id_node->find_component(DEG_NODE_TYPE_GEOMETRY);
165                                         break;
166                                 case OB_ARMATURE:
167                                         data_comp = id_node->find_component(DEG_NODE_TYPE_EVAL_POSE);
168                                         break;
169                                 /* TODO(sergey): More cases here? */
170                         }
171                         break;
172                 }
173                 case ID_ME:
174                         data_comp = id_node->find_component(DEG_NODE_TYPE_GEOMETRY);
175                         break;
176                 case ID_PA:
177                         return;
178                 case ID_LP:
179                         data_comp = id_node->find_component(DEG_NODE_TYPE_PARAMETERS);
180                         break;
181                 default:
182                         break;
183         }
184         if (data_comp == NULL) {
185 #ifdef STRICT_COMPONENT_TAGGING
186                 DEG_ERROR_PRINTF("ERROR: Unable to find data component for %s\n",
187                                  id_node->id_orig->name);
188                 BLI_assert(!"This is not supposed to happen!");
189 #endif
190                 return;
191         }
192         data_comp->tag_update(graph);
193         /* Special legacy compatibility code, tag data ID for update when object
194          * is tagged for data update.
195          */
196         if (id_type == ID_OB) {
197                 Object *object = (Object *)id_node->id_orig;
198                 ID *data_id = (ID *)object->data;
199                 if (data_id != NULL) {
200                         IDDepsNode *data_id_node = graph->find_id_node(data_id);
201                         // BLI_assert(data_id_node != NULL);
202                         /* TODO(sergey): Do we want more granular tags here? */
203                         /* TODO(sergey): Hrm, during some operations it's possible to have
204                          * object node existing but not it's data. For example, when making
205                          * objects local. This is valid situation, but how can we distinguish
206                          * that from someone trying to do stupid things with dependency
207                          * graph?
208                          */
209                         if (data_id_node != NULL) {
210                                 data_id_node->tag_update(graph);
211                         }
212                 }
213         }
214 }
215
216 /* Tag corresponding to OB_RECALC_TIME. */
217 void id_tag_update_object_time(Depsgraph *graph, IDDepsNode *id_node)
218 {
219         ComponentDepsNode *animation_comp =
220                 id_node->find_component(DEG_NODE_TYPE_ANIMATION);
221         if (animation_comp == NULL) {
222                 /* It's not necessarily we've got animation component in cases when
223                  * we are tagging for time updates.
224                  */
225                 return;
226         }
227         animation_comp->tag_update(graph);
228         /* TODO(sergey): More components to tag here? */
229 }
230
231 void id_tag_update_particle(Depsgraph *graph, IDDepsNode *id_node, int tag)
232 {
233         ComponentDepsNode *particle_comp =
234                 id_node->find_component(DEG_NODE_TYPE_PARAMETERS);
235         ParticleSettings *particle_settings = (ParticleSettings *)id_node->id_orig;
236         particle_settings->recalc |= (tag & PSYS_RECALC);
237         if (particle_comp == NULL) {
238 #ifdef STRICT_COMPONENT_TAGGING
239                 DEG_ERROR_PRINTF("ERROR: Unable to find particle component for %s\n",
240                                  id_node->id_orig->name);
241                 BLI_assert(!"This is not supposed to happen!");
242 #endif
243                 return;
244         }
245         particle_comp->tag_update(graph);
246 }
247
248 void id_tag_update_shading(Depsgraph *graph, IDDepsNode *id_node)
249 {
250         ComponentDepsNode *shading_comp;
251         if (GS(id_node->id_orig->name) == ID_NT) {
252                 shading_comp = id_node->find_component(DEG_NODE_TYPE_SHADING_PARAMETERS);
253         }
254         else {
255                 shading_comp = id_node->find_component(DEG_NODE_TYPE_SHADING);
256         }
257         if (shading_comp == NULL) {
258 #ifdef STRICT_COMPONENT_TAGGING
259                 DEG_ERROR_PRINTF("ERROR: Unable to find shading component for %s\n",
260                                  id_node->id_orig->name);
261                 BLI_assert(!"This is not supposed to happen!");
262 #endif
263                 return;
264         }
265         shading_comp->tag_update(graph);
266 }
267
268 /* Tag corresponding to DEG_TAG_COPY_ON_WRITE. */
269 void id_tag_update_copy_on_write(Depsgraph *graph, IDDepsNode *id_node)
270 {
271         if (!DEG_depsgraph_use_copy_on_write()) {
272                 return;
273         }
274         ComponentDepsNode *cow_comp =
275                 id_node->find_component(DEG_NODE_TYPE_COPY_ON_WRITE);
276         OperationDepsNode *cow_node = cow_comp->get_entry_operation();
277         cow_node->tag_update(graph);
278 }
279
280 void id_tag_update_select_update(Depsgraph *graph, IDDepsNode *id_node)
281 {
282         ComponentDepsNode *component;
283         OperationDepsNode *node = NULL;
284         const ID_Type id_type = GS(id_node->id_orig->name);
285         if (id_type == ID_SCE) {
286                 /* We need to flush base flags to all objects in a scene since we
287                  * don't know which ones changed. However, we don't want to update
288                  * the whole scene, so pick up some operation which will do as less
289                  * as possible.
290                  *
291                  * TODO(sergey): We can introduce explicit exit operation which
292                  * does nothing and which is only used to cascade flush down the
293                  * road.
294                  */
295                 component = id_node->find_component(DEG_NODE_TYPE_LAYER_COLLECTIONS);
296                 BLI_assert(component != NULL);
297                 if (component != NULL) {
298                         node = component->find_operation(DEG_OPCODE_VIEW_LAYER_DONE);
299                 }
300         }
301         else if (id_type == ID_OB) {
302                 component = id_node->find_component(DEG_NODE_TYPE_LAYER_COLLECTIONS);
303                 /* NOTE: This component might be missing for indirectly linked
304                  * objects.
305                  */
306                 if (component != NULL) {
307                         node = component->find_operation(DEG_OPCODE_OBJECT_BASE_FLAGS);
308                 }
309         }
310         else {
311                 component = id_node->find_component(DEG_NODE_TYPE_BATCH_CACHE);
312                 BLI_assert(component != NULL);
313                 if (component != NULL) {
314                         node = component->find_operation(DEG_OPCODE_GEOMETRY_SELECT_UPDATE,
315                                                          "", -1);
316                 }
317         }
318         if (node != NULL) {
319                 node->tag_update(graph);
320         }
321 }
322
323 void id_tag_update_base_flags(Depsgraph *graph, IDDepsNode *id_node)
324 {
325         ComponentDepsNode *component;
326         OperationDepsNode *node = NULL;
327         const ID_Type id_type = GS(id_node->id_orig->name);
328         if (id_type == ID_SCE) {
329                 component = id_node->find_component(DEG_NODE_TYPE_LAYER_COLLECTIONS);
330                 if (component == NULL) {
331                         return;
332                 }
333                 node = component->find_operation(DEG_OPCODE_VIEW_LAYER_INIT);
334         }
335         else if (id_type == ID_OB) {
336                 component = id_node->find_component(DEG_NODE_TYPE_LAYER_COLLECTIONS);
337                 if (component == NULL) {
338                         return;
339                 }
340                 node = component->find_operation(DEG_OPCODE_OBJECT_BASE_FLAGS);
341                 if (node == NULL) {
342                         return;
343                 }
344         }
345         if (node != NULL) {
346                 node->tag_update(graph);
347         }
348 }
349
350 void id_tag_update_editors_update(Main *bmain, Depsgraph *graph, ID *id)
351 {
352         /* NOTE: We handle this immediately, without delaying anything, to be
353          * sure we don't cause threading issues with OpenGL.
354          */
355         /* TODO(sergey): Make sure this works for CoW-ed datablocks as well. */
356         DEGEditorUpdateContext update_ctx = {NULL};
357         update_ctx.bmain = bmain;
358         update_ctx.scene = graph->scene;
359         update_ctx.view_layer = graph->view_layer;
360         deg_editors_id_update(&update_ctx, id);
361 }
362
363 void id_tag_update_ntree_special(Main *bmain, Depsgraph *graph, ID *id, int flag)
364 {
365         bNodeTree *ntree = NULL;
366         switch (GS(id->name)) {
367                 case ID_MA:
368                         ntree = ((Material *)id)->nodetree;
369                         break;
370                 default:
371                         break;
372         }
373         if (ntree == NULL) {
374                 return;
375         }
376         IDDepsNode *id_node = graph->find_id_node(&ntree->id);
377         if (id_node != NULL) {
378                 deg_graph_id_tag_update(bmain, graph, id_node->id_orig, flag);
379         }
380 }
381
382 void deg_graph_id_tag_update(Main *bmain, Depsgraph *graph, ID *id, int flag)
383 {
384         Depsgraph *deg_graph = reinterpret_cast<DEG::Depsgraph *>(graph);
385         IDDepsNode *id_node = deg_graph->find_id_node(id);
386         /* Make sure legacy flags are all nicely update. */
387         lib_id_recalc_tag_flag(bmain, id, flag);
388         if (id_node == NULL) {
389                 /* Shouldn't happen, but better be sure here. */
390                 return;
391         }
392         /* Tag components based on flags. */
393         if (flag == 0) {
394                 id_tag_update_special_zero_flag(graph, id_node);
395                 id_tag_update_ntree_special(bmain, graph, id, flag);
396                 return;
397         }
398         if (flag & OB_RECALC_OB) {
399                 id_tag_update_object_transform(graph, id_node);
400         }
401         if (flag & OB_RECALC_DATA) {
402                 id_tag_update_object_data(graph, id_node);
403                 if (DEG_depsgraph_use_copy_on_write()) {
404                         if (flag & DEG_TAG_COPY_ON_WRITE) {
405                                 const ID_Type id_type = GS(id_node->id_orig->name);
406                                 if (id_type == ID_OB) {
407                                         Object *object = (Object *)id_node->id_orig;
408                                         ID *ob_data = (ID *)object->data;
409                                         DEG_id_tag_update_ex(bmain, ob_data, flag);
410                                 }
411                         }
412                 }
413         }
414         if (flag & OB_RECALC_TIME) {
415                 id_tag_update_object_time(graph, id_node);
416         }
417         if (flag & PSYS_RECALC) {
418                 id_tag_update_particle(graph, id_node, flag);
419         }
420         if (flag & DEG_TAG_SHADING_UPDATE) {
421                 id_tag_update_shading(graph, id_node);
422         }
423         if (flag & DEG_TAG_COPY_ON_WRITE) {
424                 id_tag_update_copy_on_write(graph, id_node);
425         }
426         if (flag & DEG_TAG_SELECT_UPDATE) {
427                 id_tag_update_select_update(graph, id_node);
428         }
429         if (flag & DEG_TAG_BASE_FLAGS_UPDATE) {
430                 id_tag_update_base_flags(graph, id_node);
431         }
432         if (flag & DEG_TAG_EDITORS_UPDATE) {
433                 id_tag_update_editors_update(bmain, graph, id);
434         }
435         id_tag_update_ntree_special(bmain, graph, id, flag);
436 }
437
438 void deg_id_tag_update(Main *bmain, ID *id, int flag)
439 {
440         lib_id_recalc_tag_flag(bmain, id, flag);
441         LINKLIST_FOREACH(Scene *, scene, &bmain->scene) {
442                 LINKLIST_FOREACH(ViewLayer *, view_layer, &scene->view_layers) {
443                         Depsgraph *depsgraph =
444                                 (Depsgraph *)BKE_scene_get_depsgraph(scene,
445                                                                      view_layer,
446                                                                      false);
447                         if (depsgraph != NULL) {
448                                 deg_graph_id_tag_update(bmain, depsgraph, id, flag);
449                         }
450                 }
451         }
452 }
453
454 void deg_graph_on_visible_update(Main *bmain, Depsgraph *graph)
455 {
456         /* Make sure objects are up to date. */
457         foreach (DEG::IDDepsNode *id_node, graph->id_nodes) {
458                 const ID_Type id_type = GS(id_node->id_orig->name);
459                 int flag = 0;
460                 /* We only tag components which needs an update. Tagging everything is
461                  * not a good idea because that might reset particles cache (or any
462                  * other type of cache).
463                  *
464                  * TODO(sergey): Need to generalize this somehow.
465                  */
466                 if (id_type == ID_OB) {
467                         flag |= OB_RECALC_OB | OB_RECALC_DATA | DEG_TAG_COPY_ON_WRITE;
468                 }
469                 deg_graph_id_tag_update(bmain, graph, id_node->id_orig, flag);
470         }
471         /* Make sure collection properties are up to date. */
472         for (Scene *scene_iter = graph->scene; scene_iter != NULL; scene_iter = scene_iter->set) {
473                 IDDepsNode *scene_id_node = graph->find_id_node(&scene_iter->id);
474                 BLI_assert(scene_id_node != NULL);
475                 scene_id_node->tag_update(graph);
476         }
477 }
478
479 }  /* namespace */
480
481 }  // namespace DEG
482
483 /* Tag given ID for an update in all the dependency graphs. */
484 void DEG_id_tag_update(ID *id, int flag)
485 {
486         DEG_id_tag_update_ex(G.main, id, flag);
487 }
488
489 void DEG_id_tag_update_ex(Main *bmain, ID *id, int flag)
490 {
491         if (id == NULL) {
492                 /* Ideally should not happen, but old depsgraph allowed this. */
493                 return;
494         }
495         DEG_DEBUG_PRINTF("%s: id=%s flag=%d\n", __func__, id->name, flag);
496         DEG::deg_id_tag_update(bmain, id, flag);
497 }
498
499 void DEG_graph_id_tag_update(struct Main *bmain,
500                              struct Depsgraph *depsgraph,
501                              struct ID *id,
502                              int flag)
503 {
504         DEG::Depsgraph *graph = (DEG::Depsgraph *)depsgraph;
505         DEG::deg_graph_id_tag_update(bmain, graph, id, flag);
506 }
507
508 /* Mark a particular datablock type as having changing. */
509 void DEG_id_type_tag(Main *bmain, short id_type)
510 {
511         if (id_type == ID_NT) {
512                 /* Stupid workaround so parent datablocks of nested nodetree get looped
513                  * over when we loop over tagged datablock types.
514                  */
515                 DEG_id_type_tag(bmain, ID_MA);
516                 DEG_id_type_tag(bmain, ID_TE);
517                 DEG_id_type_tag(bmain, ID_LA);
518                 DEG_id_type_tag(bmain, ID_WO);
519                 DEG_id_type_tag(bmain, ID_SCE);
520         }
521
522         bmain->id_tag_update[BKE_idcode_to_index(id_type)] = 1;
523 }
524
525 void DEG_graph_flush_update(Main *bmain, Depsgraph *depsgraph)
526 {
527         if (depsgraph == NULL) {
528                 return;
529         }
530         DEG::deg_graph_flush_updates(bmain, (DEG::Depsgraph *)depsgraph);
531 }
532
533 /* Update dependency graph when visible scenes/layers changes. */
534 void DEG_graph_on_visible_update(Main *bmain, Depsgraph *depsgraph)
535 {
536         DEG::Depsgraph *graph = (DEG::Depsgraph *)depsgraph;
537         DEG::deg_graph_on_visible_update(bmain, graph);
538 }
539
540 void DEG_on_visible_update(Main *bmain, const bool UNUSED(do_time))
541 {
542         LINKLIST_FOREACH(Scene *, scene, &bmain->scene) {
543                 LINKLIST_FOREACH(ViewLayer *, view_layer, &scene->view_layers) {
544                         Depsgraph *depsgraph =
545                                 (Depsgraph *)BKE_scene_get_depsgraph(scene,
546                                                                      view_layer,
547                                                                      false);
548                         if (depsgraph != NULL) {
549                                 DEG_graph_on_visible_update(bmain, depsgraph);
550                         }
551                 }
552         }
553 }
554
555 /* Check if something was changed in the database and inform
556  * editors about this.
557  */
558 void DEG_ids_check_recalc(Main *bmain,
559                           Scene *scene,
560                           ViewLayer *view_layer,
561                           bool time)
562 {
563         ListBase *lbarray[MAX_LIBARRAY];
564         int a;
565         bool updated = false;
566
567         /* Loop over all ID types. */
568         a  = set_listbasepointers(bmain, lbarray);
569         while (a--) {
570                 ListBase *lb = lbarray[a];
571                 ID *id = (ID *)lb->first;
572
573                 if (id && bmain->id_tag_update[BKE_idcode_to_index(GS(id->name))]) {
574                         updated = true;
575                         break;
576                 }
577         }
578
579         DEGEditorUpdateContext update_ctx = {NULL};
580         update_ctx.bmain = bmain;
581         update_ctx.scene = scene;
582         update_ctx.view_layer = view_layer;
583         DEG::deg_editors_scene_update(&update_ctx, (updated || time));
584 }
585
586 void DEG_ids_clear_recalc(Main *bmain)
587 {
588         ListBase *lbarray[MAX_LIBARRAY];
589         bNodeTree *ntree;
590         int a;
591
592         /* TODO(sergey): Re-implement POST_UPDATE_HANDLER_WORKAROUND using entry_tags
593          * and id_tags storage from the new dependency graph.
594          */
595
596         /* Loop over all ID types. */
597         a  = set_listbasepointers(bmain, lbarray);
598         while (a--) {
599                 ListBase *lb = lbarray[a];
600                 ID *id = (ID *)lb->first;
601
602                 if (id && bmain->id_tag_update[BKE_idcode_to_index(GS(id->name))]) {
603                         for (; id; id = (ID *)id->next) {
604                                 id->tag &= ~LIB_TAG_ID_RECALC_ALL;
605
606                                 /* Some ID's contain semi-datablock nodetree */
607                                 ntree = ntreeFromID(id);
608                                 if (ntree != NULL) {
609                                         ntree->id.tag &= ~LIB_TAG_ID_RECALC_ALL;
610                                 }
611                         }
612                 }
613         }
614
615         memset(bmain->id_tag_update, 0, sizeof(bmain->id_tag_update));
616 }