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