GPencil: Fix typo error
[blender.git] / source / blender / depsgraph / intern / depsgraph_tag.cc
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2013 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup depsgraph
22  *
23  * Core routines for how the Depsgraph works.
24  */
25
26 #include "intern/depsgraph_tag.h"
27
28 #include <stdio.h>
29 #include <cstring> /* required for memset */
30 #include <queue>
31
32 #include "BLI_utildefines.h"
33 #include "BLI_listbase.h"
34 #include "BLI_math_bits.h"
35 #include "BLI_task.h"
36
37 extern "C" {
38 #include "DNA_anim_types.h"
39 #include "DNA_curve_types.h"
40 #include "DNA_key_types.h"
41 #include "DNA_lattice_types.h"
42 #include "DNA_mesh_types.h"
43 #include "DNA_object_types.h"
44 #include "DNA_particle_types.h"
45 #include "DNA_screen_types.h"
46 #include "DNA_windowmanager_types.h"
47
48 #include "BKE_animsys.h"
49 #include "BKE_global.h"
50 #include "BKE_idcode.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 #include "DEG_depsgraph_debug.h"
62 #include "DEG_depsgraph_query.h"
63
64 #include "intern/builder/deg_builder.h"
65 #include "intern/depsgraph.h"
66 #include "intern/depsgraph_update.h"
67 #include "intern/eval/deg_eval_copy_on_write.h"
68 #include "intern/eval/deg_eval_flush.h"
69 #include "intern/node/deg_node.h"
70 #include "intern/node/deg_node_component.h"
71 #include "intern/node/deg_node_factory.h"
72 #include "intern/node/deg_node_id.h"
73 #include "intern/node/deg_node_operation.h"
74
75 /* *********************** */
76 /* Update Tagging/Flushing */
77
78 namespace DEG {
79
80 namespace {
81
82 void depsgraph_geometry_tag_to_component(const ID *id, NodeType *component_type)
83 {
84   const NodeType result = geometry_tag_to_component(id);
85   if (result != NodeType::UNDEFINED) {
86     *component_type = result;
87   }
88 }
89
90 bool is_selectable_data_id_type(const ID_Type id_type)
91 {
92   return ELEM(id_type, ID_ME, ID_CU, ID_MB, ID_LT, ID_GD);
93 }
94
95 void depsgraph_select_tag_to_component_opcode(const ID *id,
96                                               NodeType *component_type,
97                                               OperationCode *operation_code)
98 {
99   const ID_Type id_type = GS(id->name);
100   if (id_type == ID_SCE) {
101     /* We need to flush base flags to all objects in a scene since we
102      * don't know which ones changed. However, we don't want to update
103      * the whole scene, so pick up some operation which will do as less
104      * as possible.
105      *
106      * TODO(sergey): We can introduce explicit exit operation which
107      * does nothing and which is only used to cascade flush down the
108      * road. */
109     *component_type = NodeType::LAYER_COLLECTIONS;
110     *operation_code = OperationCode::VIEW_LAYER_EVAL;
111   }
112   else if (id_type == ID_OB) {
113     *component_type = NodeType::OBJECT_FROM_LAYER;
114     *operation_code = OperationCode::OBJECT_BASE_FLAGS;
115   }
116   else if (id_type == ID_MC) {
117     *component_type = NodeType::BATCH_CACHE;
118     *operation_code = OperationCode::MOVIECLIP_SELECT_UPDATE;
119   }
120   else if (is_selectable_data_id_type(id_type)) {
121     *component_type = NodeType::BATCH_CACHE;
122     *operation_code = OperationCode::GEOMETRY_SELECT_UPDATE;
123   }
124   else {
125     *component_type = NodeType::COPY_ON_WRITE;
126     *operation_code = OperationCode::COPY_ON_WRITE;
127   }
128 }
129
130 void depsgraph_base_flags_tag_to_component_opcode(const ID *id,
131                                                   NodeType *component_type,
132                                                   OperationCode *operation_code)
133 {
134   const ID_Type id_type = GS(id->name);
135   if (id_type == ID_SCE) {
136     *component_type = NodeType::LAYER_COLLECTIONS;
137     *operation_code = OperationCode::VIEW_LAYER_EVAL;
138   }
139   else if (id_type == ID_OB) {
140     *component_type = NodeType::OBJECT_FROM_LAYER;
141     *operation_code = OperationCode::OBJECT_BASE_FLAGS;
142   }
143 }
144
145 OperationCode psysTagToOperationCode(IDRecalcFlag tag)
146 {
147   if (tag == ID_RECALC_PSYS_RESET) {
148     return OperationCode::PARTICLE_SETTINGS_RESET;
149   }
150   return OperationCode::OPERATION;
151 }
152
153 void depsgraph_tag_to_component_opcode(const ID *id,
154                                        IDRecalcFlag tag,
155                                        NodeType *component_type,
156                                        OperationCode *operation_code)
157 {
158   const ID_Type id_type = GS(id->name);
159   *component_type = NodeType::UNDEFINED;
160   *operation_code = OperationCode::OPERATION;
161   /* Special case for now, in the future we should get rid of this. */
162   if (tag == 0) {
163     *component_type = NodeType::ID_REF;
164     *operation_code = OperationCode::OPERATION;
165     return;
166   }
167   switch (tag) {
168     case ID_RECALC_TRANSFORM:
169       *component_type = NodeType::TRANSFORM;
170       break;
171     case ID_RECALC_GEOMETRY:
172       depsgraph_geometry_tag_to_component(id, component_type);
173       break;
174     case ID_RECALC_ANIMATION:
175       *component_type = NodeType::ANIMATION;
176       break;
177     case ID_RECALC_PSYS_REDO:
178     case ID_RECALC_PSYS_RESET:
179     case ID_RECALC_PSYS_CHILD:
180     case ID_RECALC_PSYS_PHYS:
181       if (id_type == ID_PA) {
182         /* NOTES:
183          * - For particle settings node we need to use different
184          *   component. Will be nice to get this unified with object,
185          *   but we can survive for now with single exception here.
186          *   Particles needs reconsideration anyway, */
187         *component_type = NodeType::PARTICLE_SETTINGS;
188         *operation_code = psysTagToOperationCode(tag);
189       }
190       else {
191         *component_type = NodeType::PARTICLE_SYSTEM;
192       }
193       break;
194     case ID_RECALC_COPY_ON_WRITE:
195       *component_type = NodeType::COPY_ON_WRITE;
196       break;
197     case ID_RECALC_SHADING:
198       if (id_type == ID_NT) {
199         *component_type = NodeType::SHADING_PARAMETERS;
200       }
201       else {
202         *component_type = NodeType::SHADING;
203       }
204       break;
205     case ID_RECALC_SELECT:
206       depsgraph_select_tag_to_component_opcode(id, component_type, operation_code);
207       break;
208     case ID_RECALC_BASE_FLAGS:
209       depsgraph_base_flags_tag_to_component_opcode(id, component_type, operation_code);
210       break;
211     case ID_RECALC_POINT_CACHE:
212       *component_type = NodeType::POINT_CACHE;
213       break;
214     case ID_RECALC_EDITORS:
215       /* There is no such node in depsgraph, this tag is to be handled
216        * separately. */
217       break;
218     case ID_RECALC_SEQUENCER_STRIPS:
219       *component_type = NodeType::SEQUENCER;
220       break;
221     case ID_RECALC_AUDIO_SEEK:
222     case ID_RECALC_AUDIO_FPS:
223     case ID_RECALC_AUDIO_VOLUME:
224     case ID_RECALC_AUDIO_MUTE:
225     case ID_RECALC_AUDIO_LISTENER:
226     case ID_RECALC_AUDIO:
227       *component_type = NodeType::AUDIO;
228       break;
229     case ID_RECALC_PARAMETERS:
230       *component_type = NodeType::PARAMETERS;
231       break;
232     case ID_RECALC_SOURCE:
233       *component_type = NodeType::PARAMETERS;
234       break;
235     case ID_RECALC_TIME:
236       BLI_assert(!"Should be handled outside of this function");
237       break;
238     case ID_RECALC_ALL:
239     case ID_RECALC_PSYS_ALL:
240       BLI_assert(!"Should not happen");
241       break;
242   }
243 }
244
245 void id_tag_update_ntree_special(
246     Main *bmain, Depsgraph *graph, ID *id, int flag, eUpdateSource update_source)
247 {
248   bNodeTree *ntree = ntreeFromID(id);
249   if (ntree == NULL) {
250     return;
251   }
252   graph_id_tag_update(bmain, graph, &ntree->id, flag, update_source);
253 }
254
255 void depsgraph_update_editors_tag(Main *bmain, Depsgraph *graph, ID *id)
256 {
257   /* NOTE: We handle this immediately, without delaying anything, to be
258    * sure we don't cause threading issues with OpenGL. */
259   /* TODO(sergey): Make sure this works for CoW-ed datablocks as well. */
260   DEGEditorUpdateContext update_ctx = {NULL};
261   update_ctx.bmain = bmain;
262   update_ctx.depsgraph = (::Depsgraph *)graph;
263   update_ctx.scene = graph->scene;
264   update_ctx.view_layer = graph->view_layer;
265   deg_editors_id_update(&update_ctx, id);
266 }
267
268 void depsgraph_id_tag_copy_on_write(Depsgraph *graph, IDNode *id_node, eUpdateSource update_source)
269 {
270   ComponentNode *cow_comp = id_node->find_component(NodeType::COPY_ON_WRITE);
271   cow_comp->tag_update(graph, update_source);
272 }
273
274 void depsgraph_tag_component(Depsgraph *graph,
275                              IDNode *id_node,
276                              NodeType component_type,
277                              OperationCode operation_code,
278                              eUpdateSource update_source)
279 {
280   ComponentNode *component_node = id_node->find_component(component_type);
281   /* NOTE: Animation component might not be existing yet (which happens when adding new driver or
282    * adding a new keyframe), so the required copy-on-write tag needs to be taken care explicitly
283    * here. */
284   if (component_node == NULL) {
285     if (component_type == NodeType::ANIMATION) {
286       depsgraph_id_tag_copy_on_write(graph, id_node, update_source);
287     }
288     return;
289   }
290   if (operation_code == OperationCode::OPERATION) {
291     component_node->tag_update(graph, update_source);
292   }
293   else {
294     OperationNode *operation_node = component_node->find_operation(operation_code);
295     if (operation_node != NULL) {
296       operation_node->tag_update(graph, update_source);
297     }
298   }
299   /* If component depends on copy-on-write, tag it as well. */
300   if (component_node->need_tag_cow_before_update()) {
301     depsgraph_id_tag_copy_on_write(graph, id_node, update_source);
302   }
303 }
304
305 /* This is a tag compatibility with legacy code.
306  *
307  * Mainly, old code was tagging object with ID_RECALC_GEOMETRY tag to inform
308  * that object's data datablock changed. Now API expects that ID is given
309  * explicitly, but not all areas are aware of this yet. */
310 void deg_graph_id_tag_legacy_compat(
311     Main *bmain, Depsgraph *depsgraph, ID *id, IDRecalcFlag tag, eUpdateSource update_source)
312 {
313   if (tag == ID_RECALC_GEOMETRY || tag == 0) {
314     switch (GS(id->name)) {
315       case ID_OB: {
316         Object *object = (Object *)id;
317         ID *data_id = (ID *)object->data;
318         if (data_id != NULL) {
319           graph_id_tag_update(bmain, depsgraph, data_id, 0, update_source);
320         }
321         break;
322       }
323       /* TODO(sergey): Shape keys are annoying, maybe we should find a
324        * way to chain geometry evaluation to them, so we don't need extra
325        * tagging here. */
326       case ID_ME: {
327         Mesh *mesh = (Mesh *)id;
328         if (mesh->key != NULL) {
329           ID *key_id = &mesh->key->id;
330           if (key_id != NULL) {
331             graph_id_tag_update(bmain, depsgraph, key_id, 0, update_source);
332           }
333         }
334         break;
335       }
336       case ID_LT: {
337         Lattice *lattice = (Lattice *)id;
338         if (lattice->key != NULL) {
339           ID *key_id = &lattice->key->id;
340           if (key_id != NULL) {
341             graph_id_tag_update(bmain, depsgraph, key_id, 0, update_source);
342           }
343         }
344         break;
345       }
346       case ID_CU: {
347         Curve *curve = (Curve *)id;
348         if (curve->key != NULL) {
349           ID *key_id = &curve->key->id;
350           if (key_id != NULL) {
351             graph_id_tag_update(bmain, depsgraph, key_id, 0, update_source);
352           }
353         }
354         break;
355       }
356       default:
357         break;
358     }
359   }
360 }
361
362 static void graph_id_tag_update_single_flag(Main *bmain,
363                                             Depsgraph *graph,
364                                             ID *id,
365                                             IDNode *id_node,
366                                             IDRecalcFlag tag,
367                                             eUpdateSource update_source)
368 {
369   if (tag == ID_RECALC_EDITORS) {
370     if (graph != NULL) {
371       depsgraph_update_editors_tag(bmain, graph, id);
372     }
373     return;
374   }
375   else if (tag == ID_RECALC_TIME) {
376     if (graph != NULL) {
377       graph->need_update_time = true;
378     }
379     return;
380   }
381   /* Get description of what is to be tagged. */
382   NodeType component_type;
383   OperationCode operation_code;
384   depsgraph_tag_to_component_opcode(id, tag, &component_type, &operation_code);
385   /* Check whether we've got something to tag. */
386   if (component_type == NodeType::UNDEFINED) {
387     /* Given ID does not support tag. */
388     /* TODO(sergey): Shall we raise some panic here? */
389     return;
390   }
391   /* Some sanity checks before moving forward. */
392   if (id_node == NULL) {
393     /* Happens when object is tagged for update and not yet in the
394      * dependency graph (but will be after relations update). */
395     return;
396   }
397   /* Tag ID recalc flag. */
398   DepsNodeFactory *factory = type_get_factory(component_type);
399   BLI_assert(factory != NULL);
400   id_node->id_cow->recalc |= factory->id_recalc_tag();
401   /* Tag corresponding dependency graph operation for update. */
402   if (component_type == NodeType::ID_REF) {
403     id_node->tag_update(graph, update_source);
404   }
405   else {
406     depsgraph_tag_component(graph, id_node, component_type, operation_code, update_source);
407   }
408   /* TODO(sergey): Get rid of this once all areas are using proper data ID
409    * for tagging. */
410   deg_graph_id_tag_legacy_compat(bmain, graph, id, tag, update_source);
411 }
412
413 string stringify_append_bit(const string &str, IDRecalcFlag tag)
414 {
415   string result = str;
416   if (!result.empty()) {
417     result += ", ";
418   }
419   result += DEG_update_tag_as_string(tag);
420   return result;
421 }
422
423 string stringify_update_bitfield(int flag)
424 {
425   if (flag == 0) {
426     return "LEGACY_0";
427   }
428   string result = "";
429   int current_flag = flag;
430   /* Special cases to avoid ALL flags form being split into
431    * individual bits. */
432   if ((current_flag & ID_RECALC_PSYS_ALL) == ID_RECALC_PSYS_ALL) {
433     result = stringify_append_bit(result, ID_RECALC_PSYS_ALL);
434   }
435   /* Handle all the rest of the flags. */
436   while (current_flag != 0) {
437     IDRecalcFlag tag = (IDRecalcFlag)(1 << bitscan_forward_clear_i(&current_flag));
438     result = stringify_append_bit(result, tag);
439   }
440   return result;
441 }
442
443 const char *update_source_as_string(eUpdateSource source)
444 {
445   switch (source) {
446     case DEG_UPDATE_SOURCE_TIME:
447       return "TIME";
448     case DEG_UPDATE_SOURCE_USER_EDIT:
449       return "USER_EDIT";
450     case DEG_UPDATE_SOURCE_RELATIONS:
451       return "RELATIONS";
452     case DEG_UPDATE_SOURCE_VISIBILITY:
453       return "VISIBILITY";
454   }
455   BLI_assert(!"Should never happen.");
456   return "UNKNOWN";
457 }
458
459 int deg_recalc_flags_for_legacy_zero()
460 {
461   return ID_RECALC_ALL & ~(ID_RECALC_PSYS_ALL | ID_RECALC_ANIMATION | ID_RECALC_SOURCE);
462 }
463
464 int deg_recalc_flags_effective(Depsgraph *graph, int flags)
465 {
466   if (graph != NULL) {
467     if (!graph->is_active) {
468       return 0;
469     }
470   }
471   if (flags == 0) {
472     return deg_recalc_flags_for_legacy_zero();
473   }
474   return flags;
475 }
476
477 /* Special tag function which tags all components which needs to be tagged
478  * for update flag=0.
479  *
480  * TODO(sergey): This is something to be avoid in the future, make it more
481  * explicit and granular for users to tag what they really need. */
482 void deg_graph_node_tag_zero(Main *bmain,
483                              Depsgraph *graph,
484                              IDNode *id_node,
485                              eUpdateSource update_source)
486 {
487   if (id_node == NULL) {
488     return;
489   }
490   ID *id = id_node->id_orig;
491   /* TODO(sergey): Which recalc flags to set here? */
492   id_node->id_cow->recalc |= deg_recalc_flags_for_legacy_zero();
493   GHASH_FOREACH_BEGIN (ComponentNode *, comp_node, id_node->components) {
494     if (comp_node->type == NodeType::ANIMATION) {
495       continue;
496     }
497     comp_node->tag_update(graph, update_source);
498   }
499   GHASH_FOREACH_END();
500   deg_graph_id_tag_legacy_compat(bmain, graph, id, (IDRecalcFlag)0, update_source);
501 }
502
503 void deg_graph_on_visible_update(Main *bmain, Depsgraph *graph, const bool do_time)
504 {
505   /* NOTE: It is possible to have this function called with `do_time=false` first and later (prior
506    * to evaluation though) with `do_time=true`. This means early output checks should be aware of
507    * this. */
508   for (DEG::IDNode *id_node : graph->id_nodes) {
509     if (!id_node->visible_components_mask) {
510       /* ID has no components which affects anything visible.
511        * No need bother with it to tag or anything. */
512       continue;
513     }
514     int flag = 0;
515     if (!DEG::deg_copy_on_write_is_expanded(id_node->id_cow)) {
516       flag |= ID_RECALC_COPY_ON_WRITE;
517       if (do_time) {
518         if (BKE_animdata_from_id(id_node->id_orig) != NULL) {
519           flag |= ID_RECALC_ANIMATION;
520         }
521       }
522     }
523     else {
524       if (id_node->visible_components_mask == id_node->previously_visible_components_mask) {
525         /* The ID was already visible and evaluated, all the subsequent
526          * updates and tags are to be done explicitly. */
527         continue;
528       }
529     }
530     /* We only tag components which needs an update. Tagging everything is
531      * not a good idea because that might reset particles cache (or any
532      * other type of cache).
533      *
534      * TODO(sergey): Need to generalize this somehow. */
535     const ID_Type id_type = GS(id_node->id_orig->name);
536     if (id_type == ID_OB) {
537       flag |= ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY;
538     }
539     graph_id_tag_update(bmain, graph, id_node->id_orig, flag, DEG_UPDATE_SOURCE_VISIBILITY);
540     if (id_type == ID_SCE) {
541       /* Make sure collection properties are up to date. */
542       id_node->tag_update(graph, DEG_UPDATE_SOURCE_VISIBILITY);
543     }
544     /* Now when ID is updated to the new visibility state, prevent it from
545      * being re-tagged again. Simplest way to do so is to pretend that it
546      * was already updated by the "previous" dependency graph.
547      *
548      * NOTE: Even if the on_visible_update() is called from the state when
549      * dependency graph is tagged for relations update, it will be fine:
550      * since dependency graph builder re-schedules entry tags, all the
551      * tags we request from here will be applied in the updated state of
552      * dependency graph. */
553     id_node->previously_visible_components_mask = id_node->visible_components_mask;
554   }
555 }
556
557 } /* namespace */
558
559 NodeType geometry_tag_to_component(const ID *id)
560 {
561   const ID_Type id_type = GS(id->name);
562   switch (id_type) {
563     case ID_OB: {
564       const Object *object = (Object *)id;
565       switch (object->type) {
566         case OB_MESH:
567         case OB_CURVE:
568         case OB_SURF:
569         case OB_FONT:
570         case OB_LATTICE:
571         case OB_MBALL:
572         case OB_GPENCIL:
573           return NodeType::GEOMETRY;
574         case OB_ARMATURE:
575           return NodeType::EVAL_POSE;
576           /* TODO(sergey): More cases here? */
577       }
578       break;
579     }
580     case ID_ME:
581     case ID_CU:
582     case ID_LT:
583     case ID_MB:
584       return NodeType::GEOMETRY;
585     case ID_PA: /* Particles */
586       return NodeType::UNDEFINED;
587     case ID_LP:
588       return NodeType::PARAMETERS;
589     case ID_GD:
590       return NodeType::GEOMETRY;
591     case ID_PAL: /* Palettes */
592       return NodeType::PARAMETERS;
593     case ID_MSK:
594       return NodeType::PARAMETERS;
595     default:
596       break;
597   }
598   return NodeType::UNDEFINED;
599 }
600
601 void id_tag_update(Main *bmain, ID *id, int flag, eUpdateSource update_source)
602 {
603   graph_id_tag_update(bmain, NULL, id, flag, update_source);
604   LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
605     LISTBASE_FOREACH (ViewLayer *, view_layer, &scene->view_layers) {
606       Depsgraph *depsgraph = (Depsgraph *)BKE_scene_get_depsgraph(scene, view_layer, false);
607       if (depsgraph != NULL) {
608         graph_id_tag_update(bmain, depsgraph, id, flag, update_source);
609       }
610     }
611   }
612 }
613
614 void graph_id_tag_update(
615     Main *bmain, Depsgraph *graph, ID *id, int flag, eUpdateSource update_source)
616 {
617   const int debug_flags = (graph != NULL) ? DEG_debug_flags_get((::Depsgraph *)graph) : G.debug;
618   if (debug_flags & G_DEBUG_DEPSGRAPH_TAG) {
619     printf("%s: id=%s flags=%s source=%s\n",
620            __func__,
621            id->name,
622            stringify_update_bitfield(flag).c_str(),
623            update_source_as_string(update_source));
624   }
625   IDNode *id_node = (graph != NULL) ? graph->find_id_node(id) : NULL;
626   if (graph != NULL) {
627     DEG_graph_id_type_tag(reinterpret_cast<::Depsgraph *>(graph), GS(id->name));
628   }
629   if (flag == 0) {
630     deg_graph_node_tag_zero(bmain, graph, id_node, update_source);
631   }
632   /* Store original flag in the ID.
633    * Allows to have more granularity than a node-factory based flags. */
634   if (id_node != NULL) {
635     id_node->id_cow->recalc |= flag;
636   }
637   /* When ID is tagged for update based on an user edits store the recalc flags in the original ID.
638    * This way IDs in the undo steps will have this flag preserved, making it possible to restore
639    * all needed tags when new dependency graph is created on redo.
640    * This is the only way to ensure modifications to animation data (such as keyframes i.e.)
641    * properly triggers animation update for the newly constructed dependency graph on redo (while
642    * usually newly created dependency graph skips animation update to avoid loss of unkeyed
643    * changes). */
644   if (update_source == DEG_UPDATE_SOURCE_USER_EDIT) {
645     id->recalc |= deg_recalc_flags_effective(graph, flag);
646   }
647   int current_flag = flag;
648   while (current_flag != 0) {
649     IDRecalcFlag tag = (IDRecalcFlag)(1 << bitscan_forward_clear_i(&current_flag));
650     graph_id_tag_update_single_flag(bmain, graph, id, id_node, tag, update_source);
651   }
652   /* Special case for nested node tree datablocks. */
653   id_tag_update_ntree_special(bmain, graph, id, flag, update_source);
654   /* Direct update tags means that something outside of simulated/cached
655    * physics did change and that cache is to be invalidated.
656    * This is only needed if data changes. If it's just a drawing, we keep the
657    * point cache. */
658   if (update_source == DEG_UPDATE_SOURCE_USER_EDIT && flag != ID_RECALC_SHADING) {
659     graph_id_tag_update_single_flag(
660         bmain, graph, id, id_node, ID_RECALC_POINT_CACHE, update_source);
661   }
662 }
663
664 }  // namespace DEG
665
666 const char *DEG_update_tag_as_string(IDRecalcFlag flag)
667 {
668   switch (flag) {
669     case ID_RECALC_TRANSFORM:
670       return "TRANSFORM";
671     case ID_RECALC_GEOMETRY:
672       return "GEOMETRY";
673     case ID_RECALC_ANIMATION:
674       return "ANIMATION";
675     case ID_RECALC_PSYS_REDO:
676       return "PSYS_REDO";
677     case ID_RECALC_PSYS_RESET:
678       return "PSYS_RESET";
679     case ID_RECALC_PSYS_CHILD:
680       return "PSYS_CHILD";
681     case ID_RECALC_PSYS_PHYS:
682       return "PSYS_PHYS";
683     case ID_RECALC_PSYS_ALL:
684       return "PSYS_ALL";
685     case ID_RECALC_COPY_ON_WRITE:
686       return "COPY_ON_WRITE";
687     case ID_RECALC_SHADING:
688       return "SHADING";
689     case ID_RECALC_SELECT:
690       return "SELECT";
691     case ID_RECALC_BASE_FLAGS:
692       return "BASE_FLAGS";
693     case ID_RECALC_POINT_CACHE:
694       return "POINT_CACHE";
695     case ID_RECALC_EDITORS:
696       return "EDITORS";
697     case ID_RECALC_SEQUENCER_STRIPS:
698       return "SEQUENCER_STRIPS";
699     case ID_RECALC_AUDIO_SEEK:
700       return "AUDIO_SEEK";
701     case ID_RECALC_AUDIO_FPS:
702       return "AUDIO_FPS";
703     case ID_RECALC_AUDIO_VOLUME:
704       return "AUDIO_VOLUME";
705     case ID_RECALC_AUDIO_MUTE:
706       return "AUDIO_MUTE";
707     case ID_RECALC_AUDIO_LISTENER:
708       return "AUDIO_LISTENER";
709     case ID_RECALC_AUDIO:
710       return "AUDIO";
711     case ID_RECALC_PARAMETERS:
712       return "PARAMETERS";
713     case ID_RECALC_TIME:
714       return "TIME";
715     case ID_RECALC_SOURCE:
716       return "SOURCE";
717     case ID_RECALC_ALL:
718       return "ALL";
719   }
720   BLI_assert(!"Unhandled update flag, should never happen!");
721   return "UNKNOWN";
722 }
723
724 /* Data-Based Tagging  */
725
726 /* Tag given ID for an update in all the dependency graphs. */
727 void DEG_id_tag_update(ID *id, int flag)
728 {
729   DEG_id_tag_update_ex(G.main, id, flag);
730 }
731
732 void DEG_id_tag_update_ex(Main *bmain, ID *id, int flag)
733 {
734   if (id == NULL) {
735     /* Ideally should not happen, but old depsgraph allowed this. */
736     return;
737   }
738   DEG::id_tag_update(bmain, id, flag, DEG::DEG_UPDATE_SOURCE_USER_EDIT);
739 }
740
741 void DEG_graph_id_tag_update(struct Main *bmain,
742                              struct Depsgraph *depsgraph,
743                              struct ID *id,
744                              int flag)
745 {
746   DEG::Depsgraph *graph = (DEG::Depsgraph *)depsgraph;
747   DEG::graph_id_tag_update(bmain, graph, id, flag, DEG::DEG_UPDATE_SOURCE_USER_EDIT);
748 }
749
750 /* Mark a particular datablock type as having changing. */
751 void DEG_graph_id_type_tag(Depsgraph *depsgraph, short id_type)
752 {
753   if (id_type == ID_NT) {
754     /* Stupid workaround so parent datablocks of nested nodetree get looped
755      * over when we loop over tagged datablock types. */
756     DEG_graph_id_type_tag(depsgraph, ID_MA);
757     DEG_graph_id_type_tag(depsgraph, ID_TE);
758     DEG_graph_id_type_tag(depsgraph, ID_LA);
759     DEG_graph_id_type_tag(depsgraph, ID_WO);
760     DEG_graph_id_type_tag(depsgraph, ID_SCE);
761   }
762   const int id_type_index = BKE_idcode_to_index(id_type);
763   DEG::Depsgraph *deg_graph = reinterpret_cast<DEG::Depsgraph *>(depsgraph);
764   deg_graph->id_type_updated[id_type_index] = 1;
765 }
766
767 void DEG_id_type_tag(Main *bmain, short id_type)
768 {
769   LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
770     LISTBASE_FOREACH (ViewLayer *, view_layer, &scene->view_layers) {
771       Depsgraph *depsgraph = (Depsgraph *)BKE_scene_get_depsgraph(scene, view_layer, false);
772       if (depsgraph != NULL) {
773         DEG_graph_id_type_tag(depsgraph, id_type);
774       }
775     }
776   }
777 }
778
779 void DEG_graph_flush_update(Main *bmain, Depsgraph *depsgraph)
780 {
781   if (depsgraph == NULL) {
782     return;
783   }
784   DEG::deg_graph_flush_updates(bmain, (DEG::Depsgraph *)depsgraph);
785 }
786
787 /* Update dependency graph when visible scenes/layers changes. */
788 void DEG_graph_on_visible_update(Main *bmain, Depsgraph *depsgraph, const bool do_time)
789 {
790   DEG::Depsgraph *graph = (DEG::Depsgraph *)depsgraph;
791   DEG::deg_graph_on_visible_update(bmain, graph, do_time);
792 }
793
794 void DEG_on_visible_update(Main *bmain, const bool do_time)
795 {
796   LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
797     LISTBASE_FOREACH (ViewLayer *, view_layer, &scene->view_layers) {
798       Depsgraph *depsgraph = (Depsgraph *)BKE_scene_get_depsgraph(scene, view_layer, false);
799       if (depsgraph != NULL) {
800         DEG_graph_on_visible_update(bmain, depsgraph, do_time);
801       }
802     }
803   }
804 }
805
806 /* Check if something was changed in the database and inform
807  * editors about this. */
808 void DEG_ids_check_recalc(
809     Main *bmain, Depsgraph *depsgraph, Scene *scene, ViewLayer *view_layer, bool time)
810 {
811   bool updated = time || DEG_id_type_any_updated(depsgraph);
812
813   DEGEditorUpdateContext update_ctx = {NULL};
814   update_ctx.bmain = bmain;
815   update_ctx.depsgraph = depsgraph;
816   update_ctx.scene = scene;
817   update_ctx.view_layer = view_layer;
818   DEG::deg_editors_scene_update(&update_ctx, updated);
819 }
820
821 static void deg_graph_clear_id_recalc_flags(ID *id)
822 {
823   id->recalc &= ~ID_RECALC_ALL;
824   bNodeTree *ntree = ntreeFromID(id);
825   /* Clear embedded node trees too. */
826   if (ntree) {
827     ntree->id.recalc &= ~ID_RECALC_ALL;
828   }
829 }
830
831 static void deg_graph_clear_id_node_func(void *__restrict data_v,
832                                          const int i,
833                                          const TaskParallelTLS *__restrict /*tls*/)
834 {
835   /* TODO: we clear original ID recalc flags here, but this may not work
836    * correctly when there are multiple depsgraph with others still using
837    * the recalc flag. */
838   DEG::Depsgraph *deg_graph = reinterpret_cast<DEG::Depsgraph *>(data_v);
839   DEG::IDNode *id_node = deg_graph->id_nodes[i];
840
841   id_node->is_user_modified = false;
842
843   deg_graph_clear_id_recalc_flags(id_node->id_cow);
844   if (deg_graph->is_active) {
845     deg_graph_clear_id_recalc_flags(id_node->id_orig);
846   }
847 }
848
849 void DEG_ids_clear_recalc(Main *UNUSED(bmain), Depsgraph *depsgraph)
850 {
851   DEG::Depsgraph *deg_graph = reinterpret_cast<DEG::Depsgraph *>(depsgraph);
852   /* TODO(sergey): Re-implement POST_UPDATE_HANDLER_WORKAROUND using entry_tags
853    * and id_tags storage from the new dependency graph. */
854   if (!DEG_id_type_any_updated(depsgraph)) {
855     return;
856   }
857   /* Go over all ID nodes nodes, clearing tags. */
858   const int num_id_nodes = deg_graph->id_nodes.size();
859   TaskParallelSettings settings;
860   BLI_parallel_range_settings_defaults(&settings);
861   settings.min_iter_per_thread = 1024;
862   BLI_task_parallel_range(0, num_id_nodes, deg_graph, deg_graph_clear_id_node_func, &settings);
863   memset(deg_graph->id_type_updated, 0, sizeof(deg_graph->id_type_updated));
864 }