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 /* *********************** */
71 /* Update Tagging/Flushing */
72
73 /* Legacy depsgraph did some special trickery for things like particle systems
74  * when tagging ID for an update. Ideally that tagging needs to become obsolete
75  * in favor of havng dedicated node for that which gets tagged, but for until
76  * design of those areas is more clear we'll do the same legacy code here.
77  *                                                                  - sergey -
78  */
79 #define DEPSGRAPH_USE_LEGACY_TAGGING
80
81 namespace {
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 void lib_id_recalc_tag_flag(Main *bmain, ID *id, int flag)
98 {
99         if (flag) {
100                 /* This bit of code ensures legacy object->recalc flags
101                  * are still filled in the same way as it was expected
102                  * with the old dependency graph.
103                  *
104                  * This is because some areas like motion paths and likely
105                  * some other physics baking process are doing manual scene
106                  * update on all the frames, trying to minimize number of
107                  * updates.
108                  *
109                  * But this flag will also let us to re-construct entry
110                  * nodes for update after relations update and after layer
111                  * visibility changes.
112                  */
113                 short idtype = GS(id->name);
114                 if (idtype == ID_OB) {
115                         Object *object = (Object *)id;
116                         object->recalc |= (flag & OB_RECALC_ALL);
117                 }
118
119                 if (flag & OB_RECALC_OB)
120                         lib_id_recalc_tag(bmain, id);
121                 if (flag & (OB_RECALC_DATA | PSYS_RECALC))
122                         lib_id_recalc_data_tag(bmain, id);
123         }
124         else {
125                 lib_id_recalc_tag(bmain, id);
126         }
127 }
128
129 #ifdef DEPSGRAPH_USE_LEGACY_TAGGING
130 void depsgraph_legacy_handle_update_tag(Main *bmain, ID *id, int flag)
131 {
132         if (flag) {
133                 Object *object;
134                 short idtype = GS(id->name);
135                 if (idtype == ID_PA) {
136                         ParticleSystem *psys;
137                         for (object = (Object *)bmain->object.first;
138                              object != NULL;
139                              object = (Object *)object->id.next)
140                         {
141                                 for (psys = (ParticleSystem *)object->particlesystem.first;
142                                      psys != NULL;
143                                      psys = (ParticleSystem *)psys->next)
144                                 {
145                                         if (&psys->part->id == id) {
146                                                 DEG_id_tag_update_ex(bmain, &object->id, flag & OB_RECALC_ALL);
147                                                 psys->recalc |= (flag & PSYS_RECALC);
148                                         }
149                                 }
150                         }
151                 }
152         }
153 }
154 #endif
155
156 #ifdef WITH_COPY_ON_WRITE
157 void id_tag_copy_on_write_update(Main *bmain, Depsgraph *graph, ID *id)
158 {
159         lib_id_recalc_tag(bmain, id);
160         DEG::Depsgraph *deg_graph = reinterpret_cast<DEG::Depsgraph *>(graph);
161         DEG::IDDepsNode *id_node = deg_graph->find_id_node(id);
162         DEG::ComponentDepsNode *cow_comp =
163                 id_node->find_component(DEG::DEG_NODE_TYPE_COPY_ON_WRITE);
164         DEG::OperationDepsNode *cow_node = cow_comp->get_entry_operation();
165         cow_node->tag_update(deg_graph);
166         cow_node->flag |= DEG::DEPSOP_FLAG_SKIP_FLUSH;
167 }
168 #endif
169
170 }  /* namespace */
171
172 /* Tag all nodes in ID-block for update.
173  * This is a crude measure, but is most convenient for old code.
174  */
175 void DEG_graph_id_tag_update(Main *bmain, Depsgraph *graph, ID *id)
176 {
177         DEG::Depsgraph *deg_graph = reinterpret_cast<DEG::Depsgraph *>(graph);
178         DEG::IDDepsNode *node = deg_graph->find_id_node(id);
179         lib_id_recalc_tag(bmain, id);
180         if (node != NULL) {
181                 node->tag_update(deg_graph);
182         }
183 }
184
185 /* Tag nodes related to a specific piece of data */
186 void DEG_graph_data_tag_update(Depsgraph *graph, const PointerRNA *ptr)
187 {
188         DEG::Depsgraph *deg_graph = reinterpret_cast<DEG::Depsgraph *>(graph);
189         DEG::DepsNode *node = deg_graph->find_node_from_pointer(ptr, NULL);
190         if (node != NULL) {
191                 node->tag_update(deg_graph);
192         }
193         else {
194                 printf("Missing node in %s\n", __func__);
195                 BLI_assert(!"Shouldn't happens since it'll miss crucial update.");
196         }
197 }
198
199 /* Tag nodes related to a specific property. */
200 void DEG_graph_property_tag_update(Depsgraph *graph,
201                                    const PointerRNA *ptr,
202                                    const PropertyRNA *prop)
203 {
204         DEG::Depsgraph *deg_graph = reinterpret_cast<DEG::Depsgraph *>(graph);
205         DEG::DepsNode *node = deg_graph->find_node_from_pointer(ptr, prop);
206         if (node != NULL) {
207                 node->tag_update(deg_graph);
208         }
209         else {
210                 printf("Missing node in %s\n", __func__);
211                 BLI_assert(!"Shouldn't happens since it'll miss crucial update.");
212         }
213 }
214
215 /* Tag given ID for an update in all the dependency graphs. */
216 void DEG_id_tag_update(ID *id, int flag)
217 {
218         DEG_id_tag_update_ex(G.main, id, flag);
219 }
220
221 void DEG_id_tag_update_ex(Main *bmain, ID *id, int flag)
222 {
223         if (id == NULL) {
224                 /* Ideally should not happen, but old depsgraph allowed this. */
225                 return;
226         }
227         DEG_DEBUG_PRINTF("%s: id=%s flag=%d\n", __func__, id->name, flag);
228         lib_id_recalc_tag_flag(bmain, id, flag);
229         for (Scene *scene = (Scene *)bmain->scene.first;
230              scene != NULL;
231              scene = (Scene *)scene->id.next)
232         {
233                 if (scene->depsgraph_legacy) {
234                         Depsgraph *graph = scene->depsgraph_legacy;
235                         if (flag == 0) {
236                                 /* TODO(sergey): Currently blender is still tagging IDs
237                                  * for recalc just using flag=0. This isn't totally correct
238                                  * but we'd better deal with such cases and don't fail.
239                                  */
240                                 DEG_graph_id_tag_update(bmain, graph, id);
241                                 continue;
242                         }
243                         if (flag & OB_RECALC_DATA && GS(id->name) == ID_OB) {
244                                 Object *object = (Object *)id;
245                                 if (object->data != NULL) {
246                                         DEG_graph_id_tag_update(bmain,
247                                                                 graph,
248                                                                 (ID *)object->data);
249                                 }
250                         }
251                         if (flag & (OB_RECALC_OB | OB_RECALC_DATA)) {
252                                 DEG_graph_id_tag_update(bmain, graph, id);
253                         }
254                         else if (flag & OB_RECALC_TIME) {
255                                 DEG_graph_id_tag_update(bmain, graph, id);
256                         }
257                         else if (flag & DEG_TAG_COPY_ON_WRITE) {
258 #ifdef WITH_COPY_ON_WRITE
259                                 id_tag_copy_on_write_update(bmain, graph, id);
260 #endif
261                         }
262                 }
263         }
264
265 #ifdef DEPSGRAPH_USE_LEGACY_TAGGING
266         /* Special handling from the legacy depsgraph.
267          * TODO(sergey): Need to get rid of those once all the areas
268          * are re-formulated in terms of franular nodes.
269          */
270         depsgraph_legacy_handle_update_tag(bmain, id, flag);
271 #endif
272 }
273
274 /* Tag given ID type for update. */
275 void DEG_id_type_tag(Main *bmain, short idtype)
276 {
277         if (idtype == ID_NT) {
278                 /* Stupid workaround so parent datablocks of nested nodetree get looped
279                  * over when we loop over tagged datablock types.
280                  */
281                 DEG_id_type_tag(bmain, ID_MA);
282                 DEG_id_type_tag(bmain, ID_TE);
283                 DEG_id_type_tag(bmain, ID_LA);
284                 DEG_id_type_tag(bmain, ID_WO);
285                 DEG_id_type_tag(bmain, ID_SCE);
286         }
287
288         bmain->id_tag_update[BKE_idcode_to_index(idtype)] = 1;
289 }
290
291 /* Recursively push updates out to all nodes dependent on this,
292  * until all affected are tagged and/or scheduled up for eval
293  */
294 void DEG_ids_flush_tagged(Main *bmain, Scene *scene)
295 {
296         /* TODO(sergey): Only visible scenes? */
297         if (scene->depsgraph_legacy != NULL) {
298                 DEG::deg_graph_flush_updates(
299                         bmain,
300                         reinterpret_cast<DEG::Depsgraph *>(scene->depsgraph_legacy));
301         }
302 }
303
304 /* Update dependency graph when visible scenes/layers changes. */
305 void DEG_graph_on_visible_update(Main *bmain, Scene *scene)
306 {
307         (void) bmain;
308         DEG::Depsgraph *graph = reinterpret_cast<DEG::Depsgraph *>(scene->depsgraph_legacy);
309         GHASH_FOREACH_BEGIN(DEG::IDDepsNode *, id_node, graph->id_hash)
310         {
311                 id_node->tag_update(graph);
312         }
313         GHASH_FOREACH_END();
314 }
315
316 void DEG_on_visible_update(Main *bmain, const bool UNUSED(do_time))
317 {
318         for (Scene *scene = (Scene *)bmain->scene.first;
319              scene != NULL;
320              scene = (Scene *)scene->id.next)
321         {
322                 if (scene->depsgraph_legacy != NULL) {
323                         DEG_graph_on_visible_update(bmain, scene);
324                 }
325         }
326 }
327
328 /* Check if something was changed in the database and inform
329  * editors about this.
330  */
331 void DEG_ids_check_recalc(Main *bmain, Scene *scene, bool time)
332 {
333         ListBase *lbarray[MAX_LIBARRAY];
334         int a;
335         bool updated = false;
336
337         /* Loop over all ID types. */
338         a  = set_listbasepointers(bmain, lbarray);
339         while (a--) {
340                 ListBase *lb = lbarray[a];
341                 ID *id = (ID *)lb->first;
342
343                 if (id && bmain->id_tag_update[BKE_idcode_to_index(GS(id->name))]) {
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                 if (id && bmain->id_tag_update[BKE_idcode_to_index(GS(id->name))]) {
369                         for (; id; id = (ID *)id->next) {
370                                 id->tag &= ~(LIB_TAG_ID_RECALC | LIB_TAG_ID_RECALC_DATA);
371
372                                 /* Some ID's contain semi-datablock nodetree */
373                                 ntree = ntreeFromID(id);
374                                 if (ntree != NULL) {
375                                         ntree->id.tag &= ~(LIB_TAG_ID_RECALC | LIB_TAG_ID_RECALC_DATA);
376                                 }
377                         }
378                 }
379         }
380
381         memset(bmain->id_tag_update, 0, sizeof(bmain->id_tag_update));
382 }