Merge branch 'master' into blender2.8
[blender.git] / source / blender / nodes / composite / node_composite_tree.c
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) 2007 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s):
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/nodes/composite/node_composite_tree.c
29  *  \ingroup nodes
30  */
31
32
33 #include <stdio.h>
34
35 #include "DNA_color_types.h"
36 #include "DNA_scene_types.h"
37 #include "DNA_node_types.h"
38
39 #include "BLT_translation.h"
40
41 #include "BKE_context.h"
42 #include "BKE_global.h"
43 #include "BKE_main.h"
44 #include "BKE_node.h"
45 #include "BKE_tracking.h"
46
47 #include "node_common.h"
48 #include "node_util.h"
49
50 #include "RNA_access.h"
51
52 #include "NOD_composite.h"
53 #include "node_composite_util.h"
54
55 #ifdef WITH_COMPOSITOR
56 #  include "COM_compositor.h"
57 #endif
58
59 static void composite_get_from_context(const bContext *C, bNodeTreeType *UNUSED(treetype), bNodeTree **r_ntree, ID **r_id, ID **r_from)
60 {
61         Scene *scene = CTX_data_scene(C);
62
63         *r_from = NULL;
64         *r_id = &scene->id;
65         *r_ntree = scene->nodetree;
66 }
67
68 static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCallback func)
69 {
70         func(calldata, NODE_CLASS_INPUT, N_("Input"));
71         func(calldata, NODE_CLASS_OUTPUT, N_("Output"));
72         func(calldata, NODE_CLASS_OP_COLOR, N_("Color"));
73         func(calldata, NODE_CLASS_OP_VECTOR, N_("Vector"));
74         func(calldata, NODE_CLASS_OP_FILTER, N_("Filter"));
75         func(calldata, NODE_CLASS_CONVERTOR, N_("Convertor"));
76         func(calldata, NODE_CLASS_MATTE, N_("Matte"));
77         func(calldata, NODE_CLASS_DISTORT, N_("Distort"));
78         func(calldata, NODE_CLASS_GROUP, N_("Group"));
79         func(calldata, NODE_CLASS_INTERFACE, N_("Interface"));
80         func(calldata, NODE_CLASS_LAYOUT, N_("Layout"));
81 }
82
83 static void free_node_cache(bNodeTree *UNUSED(ntree), bNode *node)
84 {
85         bNodeSocket *sock;
86
87         for (sock = node->outputs.first; sock; sock = sock->next) {
88                 if (sock->cache) {
89                         sock->cache = NULL;
90                 }
91         }
92 }
93
94 static void free_cache(bNodeTree *ntree)
95 {
96         bNode *node;
97         for (node = ntree->nodes.first; node; node = node->next)
98                 free_node_cache(ntree, node);
99 }
100
101 /* local tree then owns all compbufs */
102 static void localize(bNodeTree *UNUSED(localtree), bNodeTree *ntree)
103 {
104         bNode *node;
105         bNodeSocket *sock;
106
107         for (node = ntree->nodes.first; node; node = node->next) {
108                 /* ensure new user input gets handled ok */
109                 node->need_exec = 0;
110                 node->new_node->original = node;
111
112                 /* move over the compbufs */
113                 /* right after ntreeCopyTree() oldsock pointers are valid */
114
115                 if (ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)) {
116                         if (node->id) {
117                                 if (node->flag & NODE_DO_OUTPUT)
118                                         node->new_node->id = (ID *)node->id;
119                                 else
120                                         node->new_node->id = NULL;
121                         }
122                 }
123
124                 for (sock = node->outputs.first; sock; sock = sock->next) {
125                         sock->new_sock->cache = sock->cache;
126                         sock->cache = NULL;
127                         sock->new_sock->new_sock = sock;
128                 }
129         }
130 }
131
132 static void local_sync(bNodeTree *localtree, bNodeTree *ntree)
133 {
134         BKE_node_preview_sync_tree(ntree, localtree);
135 }
136
137 static void local_merge(Main *bmain, bNodeTree *localtree, bNodeTree *ntree)
138 {
139         bNode *lnode;
140         bNodeSocket *lsock;
141
142         /* move over the compbufs and previews */
143         BKE_node_preview_merge_tree(ntree, localtree, true);
144
145         for (lnode = localtree->nodes.first; lnode; lnode = lnode->next) {
146                 if (ntreeNodeExists(ntree, lnode->new_node)) {
147                         if (ELEM(lnode->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)) {
148                                 if (lnode->id && (lnode->flag & NODE_DO_OUTPUT)) {
149                                         /* image_merge does sanity check for pointers */
150                                         BKE_image_merge(bmain, (Image *)lnode->new_node->id, (Image *)lnode->id);
151                                 }
152                         }
153                         else if (lnode->type == CMP_NODE_MOVIEDISTORTION) {
154                                 /* special case for distortion node: distortion context is allocating in exec function
155                                  * and to achieve much better performance on further calls this context should be
156                                  * copied back to original node */
157                                 if (lnode->storage) {
158                                         if (lnode->new_node->storage)
159                                                 BKE_tracking_distortion_free(lnode->new_node->storage);
160
161                                         lnode->new_node->storage = BKE_tracking_distortion_copy(lnode->storage);
162                                 }
163                         }
164
165                         for (lsock = lnode->outputs.first; lsock; lsock = lsock->next) {
166                                 if (ntreeOutputExists(lnode->new_node, lsock->new_sock)) {
167                                         lsock->new_sock->cache = lsock->cache;
168                                         lsock->cache = NULL;
169                                         lsock->new_sock = NULL;
170                                 }
171                         }
172                 }
173         }
174 }
175
176 static void update(bNodeTree *ntree)
177 {
178         ntreeSetOutput(ntree);
179
180         ntree_update_reroute_nodes(ntree);
181
182         if (ntree->update & NTREE_UPDATE_NODES) {
183                 /* clean up preview cache, in case nodes have been removed */
184                 BKE_node_preview_remove_unused(ntree);
185         }
186 }
187
188 static void composite_node_add_init(bNodeTree *UNUSED(bnodetree), bNode *bnode)
189 {
190         /* Composite node will only show previews for input classes
191          * by default, other will be hidden
192          * but can be made visible with the show_preview option */
193         if (bnode->typeinfo->nclass != NODE_CLASS_INPUT) {
194                 bnode->flag &= ~NODE_PREVIEW;
195         }
196 }
197
198 bNodeTreeType *ntreeType_Composite;
199
200 void register_node_tree_type_cmp(void)
201 {
202         bNodeTreeType *tt = ntreeType_Composite = MEM_callocN(sizeof(bNodeTreeType), "compositor node tree type");
203
204         tt->type = NTREE_COMPOSIT;
205         strcpy(tt->idname, "CompositorNodeTree");
206         strcpy(tt->ui_name, "Compositing");
207         tt->ui_icon = 0;    /* defined in drawnode.c */
208         strcpy(tt->ui_description, "Compositing nodes");
209
210         tt->free_cache = free_cache;
211         tt->free_node_cache = free_node_cache;
212         tt->foreach_nodeclass = foreach_nodeclass;
213         tt->localize = localize;
214         tt->local_sync = local_sync;
215         tt->local_merge = local_merge;
216         tt->update = update;
217         tt->get_from_context = composite_get_from_context;
218         tt->node_add_init = composite_node_add_init;
219
220         tt->ext.srna = &RNA_CompositorNodeTree;
221
222         ntreeTypeAdd(tt);
223 }
224
225 void *COM_linker_hack = NULL;
226
227 void ntreeCompositExecTree(Scene *scene, bNodeTree *ntree, RenderData *rd, int rendering, int do_preview,
228                            const ColorManagedViewSettings *view_settings,
229                            const ColorManagedDisplaySettings *display_settings,
230                            const char *view_name)
231 {
232 #ifdef WITH_COMPOSITOR
233         COM_execute(rd, scene, ntree, rendering, view_settings, display_settings, view_name);
234 #else
235         UNUSED_VARS(scene, ntree, rd, rendering, view_settings, display_settings, view_name);
236 #endif
237
238         UNUSED_VARS(do_preview);
239 }
240
241 /* *********************************************** */
242
243 /* Update the outputs of the render layer nodes.
244  * Since the outputs depend on the render engine, this part is a bit complex:
245  * - ntreeCompositUpdateRLayers is called and loops over all render layer nodes
246  * - Each render layer node calls the update function of the render engine that's used for its scene
247  * - The render engine calls RE_engine_register_pass for each pass
248  * - RE_engine_register_pass calls ntreeCompositRegisterPass,
249  *   which calls node_cmp_rlayers_register_pass for every render layer node
250  */
251 void ntreeCompositUpdateRLayers(bNodeTree *ntree)
252 {
253         bNode *node;
254
255         if (ntree == NULL) return;
256
257         for (node = ntree->nodes.first; node; node = node->next) {
258                 if (node->type == CMP_NODE_R_LAYERS)
259                         node_cmp_rlayers_outputs(ntree, node);
260         }
261
262 }
263
264 void ntreeCompositRegisterPass(bNodeTree *ntree, Scene *scene, ViewLayer *view_layer, const char *name, int type)
265 {
266         bNode *node;
267
268         if (ntree == NULL) return;
269
270         for (node = ntree->nodes.first; node; node = node->next) {
271                 if (node->type == CMP_NODE_R_LAYERS)
272                         node_cmp_rlayers_register_pass(ntree, node, scene, view_layer, name, type);
273         }
274
275 }
276
277 /* called from render pipeline, to tag render input and output */
278 /* need to do all scenes, to prevent errors when you re-render 1 scene */
279 void ntreeCompositTagRender(Scene *curscene)
280 {
281         Scene *sce;
282
283         for (sce = G.main->scene.first; sce; sce = sce->id.next) {
284                 if (sce->nodetree) {
285                         bNode *node;
286
287                         for (node = sce->nodetree->nodes.first; node; node = node->next) {
288                                 if (node->id == (ID *)curscene || node->type == CMP_NODE_COMPOSITE)
289                                         nodeUpdate(sce->nodetree, node);
290                                 else if (node->type == CMP_NODE_TEXTURE) /* uses scene sizex/sizey */
291                                         nodeUpdate(sce->nodetree, node);
292                         }
293                 }
294         }
295 }
296
297 static int node_animation_properties(bNodeTree *ntree, bNode *node)
298 {
299         bNodeSocket *sock;
300         const ListBase *lb;
301         Link *link;
302         PointerRNA ptr;
303         PropertyRNA *prop;
304
305         /* check to see if any of the node's properties have fcurves */
306         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &ptr);
307         lb = RNA_struct_type_properties(ptr.type);
308
309         for (link = lb->first; link; link = link->next) {
310                 prop = (PropertyRNA *)link;
311
312                 if (RNA_property_animated(&ptr, prop)) {
313                         nodeUpdate(ntree, node);
314                         return 1;
315                 }
316         }
317
318         /* now check node sockets */
319         for (sock = node->inputs.first; sock; sock = sock->next) {
320                 RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr);
321                 prop = RNA_struct_find_property(&ptr, "default_value");
322
323                 if (RNA_property_animated(&ptr, prop)) {
324                         nodeUpdate(ntree, node);
325                         return 1;
326                 }
327         }
328
329         return 0;
330 }
331
332 /* tags nodes that have animation capabilities */
333 int ntreeCompositTagAnimated(bNodeTree *ntree)
334 {
335         bNode *node;
336         int tagged = 0;
337
338         if (ntree == NULL) return 0;
339
340         for (node = ntree->nodes.first; node; node = node->next) {
341
342                 tagged = node_animation_properties(ntree, node);
343
344                 /* otherwise always tag these node types */
345                 if (node->type == CMP_NODE_IMAGE) {
346                         Image *ima = (Image *)node->id;
347                         if (ima && BKE_image_is_animated(ima)) {
348                                 nodeUpdate(ntree, node);
349                                 tagged = 1;
350                         }
351                 }
352                 else if (node->type == CMP_NODE_TIME) {
353                         nodeUpdate(ntree, node);
354                         tagged = 1;
355                 }
356                 /* here was tag render layer, but this is called after a render, so re-composites fail */
357                 else if (node->type == NODE_GROUP) {
358                         if (ntreeCompositTagAnimated((bNodeTree *)node->id)) {
359                                 nodeUpdate(ntree, node);
360                         }
361                 }
362                 else if (ELEM(node->type, CMP_NODE_MOVIECLIP, CMP_NODE_TRANSFORM)) {
363                         nodeUpdate(ntree, node);
364                         tagged = 1;
365                 }
366                 else if (node->type == CMP_NODE_MASK) {
367                         nodeUpdate(ntree, node);
368                         tagged = 1;
369                 }
370         }
371
372         return tagged;
373 }
374
375
376 /* called from image window preview */
377 void ntreeCompositTagGenerators(bNodeTree *ntree)
378 {
379         bNode *node;
380
381         if (ntree == NULL) return;
382
383         for (node = ntree->nodes.first; node; node = node->next) {
384                 if (ELEM(node->type, CMP_NODE_R_LAYERS, CMP_NODE_IMAGE))
385                         nodeUpdate(ntree, node);
386         }
387 }
388
389 /* XXX after render animation system gets a refresh, this call allows composite to end clean */
390 void ntreeCompositClearTags(bNodeTree *ntree)
391 {
392         bNode *node;
393
394         if (ntree == NULL) return;
395
396         for (node = ntree->nodes.first; node; node = node->next) {
397                 node->need_exec = 0;
398                 if (node->type == NODE_GROUP)
399                         ntreeCompositClearTags((bNodeTree *)node->id);
400         }
401 }