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