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>
35 #include <queue>
36
37 extern "C" {
38 #include "BLI_utildefines.h"
39
40 #include "DNA_object_types.h"
41 #include "DNA_screen_types.h"
42 #include "DNA_windowmanager_types.h"
43
44 #include "BLI_task.h"
45
46 #include "BKE_library.h"
47 #include "BKE_main.h"
48 #include "BKE_node.h"
49
50 #define new new_
51 #include "BKE_screen.h"
52 #undef new
53
54 #include "DEG_depsgraph.h"
55 } /* extern "C" */
56
57 #include "intern/eval/deg_eval_flush.h"
58
59 #include "intern/nodes/deg_node.h"
60 #include "intern/nodes/deg_node_component.h"
61 #include "intern/nodes/deg_node_operation.h"
62
63 #include "intern/depsgraph_intern.h"
64 #include "util/deg_util_foreach.h"
65
66 /* *********************** */
67 /* Update Tagging/Flushing */
68
69 /* Legacy depsgraph did some special trickery for things like particle systems
70  * when tagging ID for an update. Ideally that tagging needs to become obsolete
71  * in favor of havng dedicated node for that which gets tagged, but for until
72  * design of those areas is more clear we'll do the same legacy code here.
73  *                                                                  - sergey -
74  */
75 #define DEPSGRAPH_USE_LEGACY_TAGGING
76
77 namespace {
78
79 /* Data-Based Tagging ------------------------------- */
80
81 void lib_id_recalc_tag(Main *bmain, ID *id)
82 {
83         id->tag |= LIB_TAG_ID_RECALC;
84         DEG_id_type_tag(bmain, GS(id->name));
85 }
86
87 void lib_id_recalc_data_tag(Main *bmain, ID *id)
88 {
89         id->tag |= LIB_TAG_ID_RECALC_DATA;
90         DEG_id_type_tag(bmain, GS(id->name));
91 }
92
93 void lib_id_recalc_tag_flag(Main *bmain, ID *id, int flag)
94 {
95         if (flag) {
96                 /* This bit of code ensures legacy object->recalc flags
97                  * are still filled in the same way as it was expected
98                  * with the old dependency graph.
99                  *
100                  * This is because some areas like motion paths and likely
101                  * some other physics baking process are doing manual scene
102                  * update on all the frames, trying to minimize number of
103                  * updates.
104                  *
105                  * But this flag will also let us to re-construct entry
106                  * nodes for update after relations update and after layer
107                  * visibility changes.
108                  */
109                 short idtype = GS(id->name);
110                 if (idtype == ID_OB) {
111                         Object *object = (Object *)id;
112                         object->recalc |= (flag & OB_RECALC_ALL);
113                 }
114
115                 if (flag & OB_RECALC_OB)
116                         lib_id_recalc_tag(bmain, id);
117                 if (flag & OB_RECALC_DATA)
118                         lib_id_recalc_data_tag(bmain, id);
119         }
120         else {
121                 lib_id_recalc_tag(bmain, id);
122         }
123 }
124
125 }  /* namespace */
126
127 /* Tag all nodes in ID-block for update.
128  * This is a crude measure, but is most convenient for old code.
129  */
130 void DEG_graph_id_tag_update(Main *bmain, Depsgraph *graph, ID *id)
131 {
132         DEG::Depsgraph *deg_graph = reinterpret_cast<DEG::Depsgraph *>(graph);
133         DEG::IDDepsNode *node = deg_graph->find_id_node(id);
134         lib_id_recalc_tag(bmain, id);
135         if (node != NULL) {
136                 node->tag_update(deg_graph);
137         }
138 }
139
140 /* Tag nodes related to a specific piece of data */
141 void DEG_graph_data_tag_update(Depsgraph *graph, const PointerRNA *ptr)
142 {
143         DEG::Depsgraph *deg_graph = reinterpret_cast<DEG::Depsgraph *>(graph);
144         DEG::DepsNode *node = deg_graph->find_node_from_pointer(ptr, NULL);
145         if (node != NULL) {
146                 node->tag_update(deg_graph);
147         }
148         else {
149                 printf("Missing node in %s\n", __func__);
150                 BLI_assert(!"Shouldn't happens since it'll miss crucial update.");
151         }
152 }
153
154 /* Tag nodes related to a specific property. */
155 void DEG_graph_property_tag_update(Depsgraph *graph,
156                                    const PointerRNA *ptr,
157                                    const PropertyRNA *prop)
158 {
159         DEG::Depsgraph *deg_graph = reinterpret_cast<DEG::Depsgraph *>(graph);
160         DEG::DepsNode *node = deg_graph->find_node_from_pointer(ptr, prop);
161         if (node != NULL) {
162                 node->tag_update(deg_graph);
163         }
164         else {
165                 printf("Missing node in %s\n", __func__);
166                 BLI_assert(!"Shouldn't happens since it'll miss crucial update.");
167         }
168 }
169
170 /* Tag given ID for an update in all the dependency graphs. */
171 void DEG_id_tag_update(ID *id, short flag)
172 {
173         DEG_id_tag_update_ex(G.main, id, flag);
174 }
175
176 void DEG_id_tag_update_ex(Main *bmain, ID *id, short flag)
177 {
178         if (id == NULL) {
179                 /* Ideally should not happen, but old depsgraph allowed this. */
180                 return;
181         }
182         DEG_DEBUG_PRINTF("%s: id=%s flag=%d\n", __func__, id->name, flag);
183         lib_id_recalc_tag_flag(bmain, id, flag);
184         for (Scene *scene = (Scene *)bmain->scene.first;
185              scene != NULL;
186              scene = (Scene *)scene->id.next)
187         {
188                 if (scene->depsgraph) {
189                         Depsgraph *graph = scene->depsgraph;
190                         if (flag == 0) {
191                                 /* TODO(sergey): Currently blender is still tagging IDs
192                                  * for recalc just using flag=0. This isn't totally correct
193                                  * but we'd better deal with such cases and don't fail.
194                                  */
195                                 DEG_graph_id_tag_update(bmain, graph, id);
196                                 continue;
197                         }
198                         if (flag & OB_RECALC_DATA && GS(id->name) == ID_OB) {
199                                 Object *object = (Object *)id;
200                                 if (object->data != NULL) {
201                                         DEG_graph_id_tag_update(bmain,
202                                                                 graph,
203                                                                 (ID *)object->data);
204                                 }
205                         }
206                         if (flag & (OB_RECALC_OB | OB_RECALC_DATA)) {
207                                 DEG_graph_id_tag_update(bmain, graph, id);
208                         }
209                 }
210         }
211 }
212
213 /* Tag given ID type for update. */
214 void DEG_id_type_tag(Main *bmain, short idtype)
215 {
216         if (idtype == ID_NT) {
217                 /* Stupid workaround so parent datablocks of nested nodetree get looped
218                  * over when we loop over tagged datablock types.
219                  */
220                 DEG_id_type_tag(bmain, ID_MA);
221                 DEG_id_type_tag(bmain, ID_TE);
222                 DEG_id_type_tag(bmain, ID_LA);
223                 DEG_id_type_tag(bmain, ID_WO);
224                 DEG_id_type_tag(bmain, ID_SCE);
225         }
226         /* We tag based on first ID type character to avoid
227          * looping over all ID's in case there are no tags.
228          */
229         bmain->id_tag_update[((unsigned char *)&idtype)[0]] = 1;
230 }
231
232 /* Recursively push updates out to all nodes dependent on this,
233  * until all affected are tagged and/or scheduled up for eval
234  */
235 void DEG_ids_flush_tagged(Main *bmain)
236 {
237         for (Scene *scene = (Scene *)bmain->scene.first;
238              scene != NULL;
239              scene = (Scene *)scene->id.next)
240         {
241                 /* TODO(sergey): Only visible scenes? */
242                 if (scene->depsgraph != NULL) {
243                         DEG::deg_graph_flush_updates(
244                                 bmain,
245                                 reinterpret_cast<DEG::Depsgraph *>(scene->depsgraph));
246                 }
247         }
248 }
249
250 /* Update dependency graph when visible scenes/layers changes. */
251 void DEG_graph_on_visible_update(Main *bmain, Scene *scene)
252 {
253         DEG::Depsgraph *graph = reinterpret_cast<DEG::Depsgraph *>(scene->depsgraph);
254         wmWindowManager *wm = (wmWindowManager *)bmain->wm.first;
255         int old_layers = graph->layers;
256         if (wm != NULL) {
257                 BKE_main_id_tag_listbase(&bmain->scene, LIB_TAG_DOIT, true);
258                 graph->layers = 0;
259                 for (wmWindow *win = (wmWindow *)wm->windows.first;
260                      win != NULL;
261                      win = (wmWindow *)win->next)
262                 {
263                         Scene *scene = win->screen->scene;
264                         if (scene->id.tag & LIB_TAG_DOIT) {
265                                 graph->layers |= BKE_screen_visible_layers(win->screen, scene);
266                                 scene->id.tag &= ~LIB_TAG_DOIT;
267                         }
268                 }
269         }
270         else {
271                 /* All the layers for background render for now. */
272                 graph->layers = (1 << 20) - 1;
273         }
274         if (old_layers != graph->layers) {
275                 /* Tag all objects which becomes visible (or which becomes needed for dependencies)
276                  * for recalc.
277                  *
278                  * This is mainly needed on file load only, after that updates of invisible objects
279                  * will be stored in the pending list.
280                  */
281                 GHASH_FOREACH_BEGIN(DEG::IDDepsNode *, id_node, graph->id_hash)
282                 {
283                         ID *id = id_node->id;
284                         if ((id->tag & LIB_TAG_ID_RECALC_ALL) != 0 ||
285                             (id_node->layers & scene->lay_updated) == 0)
286                         {
287                                 id_node->tag_update(graph);
288                         }
289                         /* A bit of magic: if object->recalc is set it means somebody tagged
290                          * it for update. If corresponding ID recalc flags are zero it means
291                          * graph has been evaluated after that and the recalc was skipped
292                          * because of visibility check.
293                          */
294                         if (GS(id->name) == ID_OB) {
295                                 Object *object = (Object *)id;
296                                 if ((id->tag & LIB_TAG_ID_RECALC_ALL) == 0 &&
297                                     (object->recalc & OB_RECALC_ALL) != 0)
298                                 {
299                                         id_node->tag_update(graph);
300                                         DEG::ComponentDepsNode *anim_comp =
301                                                 id_node->find_component(DEG::DEPSNODE_TYPE_ANIMATION);
302                                         if (anim_comp != NULL && object->recalc & OB_RECALC_TIME) {
303                                                 anim_comp->tag_update(graph);
304                                         }
305                                 }
306                         }
307                 }
308                 GHASH_FOREACH_END();
309         }
310         scene->lay_updated |= graph->layers;
311 }
312
313 void DEG_on_visible_update(Main *bmain, const bool UNUSED(do_time))
314 {
315         for (Scene *scene = (Scene *)bmain->scene.first;
316              scene != NULL;
317              scene = (Scene *)scene->id.next)
318         {
319                 if (scene->depsgraph != NULL) {
320                         DEG_graph_on_visible_update(bmain, scene);
321                 }
322         }
323 }
324
325 /* Check if something was changed in the database and inform
326  * editors about this.
327  */
328 void DEG_ids_check_recalc(Main *bmain, Scene *scene, bool time)
329 {
330         ListBase *lbarray[MAX_LIBARRAY];
331         int a;
332         bool updated = false;
333
334         /* Loop over all ID types. */
335         a  = set_listbasepointers(bmain, lbarray);
336         while (a--) {
337                 ListBase *lb = lbarray[a];
338                 ID *id = (ID *)lb->first;
339
340                 /* We tag based on first ID type character to avoid
341                  * looping over all ID's in case there are no tags.
342                  */
343                 if (id && bmain->id_tag_update[(unsigned char)id->name[0]]) {
344                         updated = true;
345                         break;
346                 }
347         }
348
349         DEG::deg_editors_scene_update(bmain, scene, (updated || time));
350 }
351
352 void DEG_ids_clear_recalc(Main *bmain)
353 {
354         ListBase *lbarray[MAX_LIBARRAY];
355         bNodeTree *ntree;
356         int a;
357
358         /* TODO(sergey): Re-implement POST_UPDATE_HANDLER_WORKAROUND using entry_tags
359          * and id_tags storage from the new dependency graph.
360          */
361
362         /* Loop over all ID types. */
363         a  = set_listbasepointers(bmain, lbarray);
364         while (a--) {
365                 ListBase *lb = lbarray[a];
366                 ID *id = (ID *)lb->first;
367
368                 /* We tag based on first ID type character to avoid
369                  * looping over all ID's in case there are no tags.
370                  */
371                 if (id && bmain->id_tag_update[(unsigned char)id->name[0]]) {
372                         for (; id; id = (ID *)id->next) {
373                                 id->tag &= ~(LIB_TAG_ID_RECALC | LIB_TAG_ID_RECALC_DATA);
374
375                                 /* Some ID's contain semi-datablock nodetree */
376                                 ntree = ntreeFromID(id);
377                                 if (ntree != NULL) {
378                                         ntree->id.tag &= ~(LIB_TAG_ID_RECALC | LIB_TAG_ID_RECALC_DATA);
379                                 }
380                         }
381                 }
382         }
383
384         memset(bmain->id_tag_update, 0, sizeof(bmain->id_tag_update));
385 }