Fixed potential crash in NodeTagIDChanged. Discovered after merge trunk
[blender.git] / source / blender / nodes / composite / nodes / node_composite_common.c
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. 
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2006 Blender Foundation.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): Campbell Barton, Alfredo de Greef, David Millan Escriva,
26  * Juho Vepsäläinen
27  *
28  * ***** END GPL LICENSE BLOCK *****
29  */
30
31 /** \file blender/nodes/composite/nodes/node_composite_common.c
32  *  \ingroup cmpnodes
33  */
34
35
36 #include "DNA_node_types.h"
37
38 #include "BKE_node.h"
39
40 #include "node_composite_util.h"
41 #include "node_common.h"
42 #include "node_exec.h"
43
44 #if 0
45 static void PRINT_BUFFERS(bNodeTreeExec *exec)
46 {
47         bNodeTree *ntree= exec->nodetree;
48         bNode *node;
49         bNodeSocket *sock;
50         bNodeStack *ns;
51         int i;
52         
53         printf("-------------- DEBUG --------------\n");
54         for (sock=ntree->inputs.first, i=0; sock; sock=sock->next, ++i) {
55                 ns = node_get_socket_stack(exec->stack, sock);
56                 printf("%d. Tree Input %s", i, sock->name);
57                 if (ns->external)
58                         printf(" (external)");
59                 printf(": data=%p\n", ns->data);
60         }
61         for (sock=ntree->outputs.first, i=0; sock; sock=sock->next, ++i) {
62                 ns = node_get_socket_stack(exec->stack, sock);
63                 printf("%d. Tree Output %s", i, sock->name);
64                 if (ns->external)
65                         printf(" (external)");
66                 printf(": data=%p\n", ns->data);
67         }
68         for (node=ntree->nodes.first; node; node=node->next) {
69                 printf("Node %s:\n", node->name);
70                 for (sock=node->inputs.first, i=0; sock; sock=sock->next, ++i) {
71                         ns = node_get_socket_stack(exec->stack, sock);
72                         printf("\t%d. Input %s", i, sock->name);
73                         if (ns->external)
74                                 printf(" (external)");
75                         printf(": data=%p\n", ns->data);
76                 }
77                 for (sock=node->outputs.first, i=0; sock; sock=sock->next, ++i) {
78                         ns = node_get_socket_stack(exec->stack, sock);
79                         printf("\t%d. Output %s", i, sock->name);
80                         if (ns->external)
81                                 printf(" (external)");
82                         printf(": data=%p\n", ns->data);
83                 }
84         }
85 }
86 #endif
87
88 static void copy_stack(bNodeStack *to, bNodeStack *from)
89 {
90         if (to != from) {
91                 copy_v4_v4(to->vec, from->vec);
92                 to->data = from->data;
93                 to->datatype = from->datatype;
94                 
95                 /* tag as copy to prevent freeing */
96                 to->is_copy = 1;
97         }
98 }
99
100 static void move_stack(bNodeStack *to, bNodeStack *from)
101 {
102         if (to != from) {
103                 copy_v4_v4(to->vec, from->vec);
104                 to->data = from->data;
105                 to->datatype = from->datatype;
106                 to->is_copy = from->is_copy;
107                 
108                 zero_v4(from->vec);
109                 from->data = NULL;
110                 from->datatype = 0;
111                 from->is_copy = 0;
112         }
113 }
114
115 /**** GROUP ****/
116
117 static void *group_initexec(bNode *node)
118 {
119         bNodeTree *ngroup= (bNodeTree*)node->id;
120         bNodeTreeExec *exec;
121         bNodeSocket *sock;
122         bNodeStack *ns;
123         
124         /* initialize the internal node tree execution */
125         exec = ntreeCompositBeginExecTree(ngroup, 0);
126         
127         /* tag group outputs as external to prevent freeing */
128         for (sock=ngroup->outputs.first; sock; sock=sock->next) {
129                 if (!(sock->flag & SOCK_INTERNAL)) {
130                         ns = node_get_socket_stack(exec->stack, sock);
131                         ns->external = 1;
132                 }
133         }
134
135         return exec;
136 }
137
138 static void group_freeexec(bNode *UNUSED(node), void *nodedata)
139 {
140         bNodeTreeExec *gexec= (bNodeTreeExec*)nodedata;
141         
142         ntreeCompositEndExecTree(gexec, 0);
143 }
144
145 /* Copy inputs to the internal stack.
146  * This is a shallow copy, no buffers are duplicated here!
147  */
148 static void group_copy_inputs(bNode *node, bNodeStack **in, bNodeStack *gstack)
149 {
150         bNodeSocket *sock;
151         bNodeStack *ns;
152         int a;
153         for (sock=node->inputs.first, a=0; sock; sock=sock->next, ++a) {
154                 if (sock->groupsock) {
155                         ns = node_get_socket_stack(gstack, sock->groupsock);
156                         copy_stack(ns, in[a]);
157                 }
158         }
159 }
160
161 /* Copy internal results to the external outputs.
162  */
163 static void group_move_outputs(bNode *node, bNodeStack **out, bNodeStack *gstack)
164 {
165         bNodeSocket *sock;
166         bNodeStack *ns;
167         int a;
168         for (sock=node->outputs.first, a=0; sock; sock=sock->next, ++a) {
169                 if (sock->groupsock) {
170                         ns = node_get_socket_stack(gstack, sock->groupsock);
171                         move_stack(out[a], ns);
172                 }
173         }
174 }
175
176 /* Free internal buffers */
177 static void group_free_internal(bNodeTreeExec *gexec) {
178         bNodeStack *ns;
179         int i;
180         
181         for (i=0, ns=gexec->stack; i < gexec->stacksize; ++i, ++ns) {
182                 if (!ns->external && !ns->is_copy) {
183                         if (ns->data) {
184                                 free_compbuf(ns->data);
185                                 ns->data = NULL;
186                         }
187                 }
188         }
189 }
190
191 static void group_execute(void *data, int thread, struct bNode *node, void *nodedata, struct bNodeStack **in, struct bNodeStack **out)
192 {
193         bNodeTreeExec *exec= (bNodeTreeExec*)nodedata;
194         
195         /* XXX same behavior as trunk: all nodes inside group are executed.
196          * it's stupid, but just makes it work. compo redesign will do this better.
197          */
198         {
199                 bNode *inode;
200                 for (inode=exec->nodetree->nodes.first; inode; inode=inode->next)
201                         inode->need_exec = 1;
202         }
203         
204         group_copy_inputs(node, in, exec->stack);
205         ntreeExecNodes(exec, data, thread);
206         group_free_internal(exec);
207         group_move_outputs(node, out, exec->stack);
208 }
209
210 void register_node_type_cmp_group(ListBase *lb)
211 {
212         static bNodeType ntype;
213
214         node_type_base(&ntype, NODE_GROUP, "Group", NODE_CLASS_GROUP, NODE_OPTIONS|NODE_CONST_OUTPUT);
215         node_type_socket_templates(&ntype, NULL, NULL);
216         node_type_size(&ntype, 120, 60, 200);
217         node_type_label(&ntype, node_group_label);
218         node_type_init(&ntype, node_group_init);
219         node_type_valid(&ntype, node_group_valid);
220         node_type_template(&ntype, node_group_template);
221         node_type_update(&ntype, NULL, node_group_verify);
222         node_type_group_edit(&ntype, node_group_edit_get, node_group_edit_set, node_group_edit_clear);
223         node_type_exec_new(&ntype, group_initexec, group_freeexec, group_execute);
224         
225         nodeRegisterType(lb, &ntype);
226 }
227
228
229 /**** FOR LOOP ****/
230
231 #if 0 /* XXX loop nodes don't work nicely with current trees */
232 /* Move the results from the previous iteration back to the input sockets. */
233 static void loop_iteration_reset(bNodeTree *ngroup, bNodeStack *gstack)
234 {
235         bNodeSocket *gin, *gout;
236         bNodeStack *nsin, *nsout;
237         
238         gin = ngroup->inputs.first;
239         gout = ngroup->outputs.first;
240         
241         while (gin && gout) {
242                 /* skip static (non-looping) sockets */
243                 while (gin && !(gin->flag & SOCK_DYNAMIC))
244                         gin=gin->next;
245                 while (gout && !(gout->flag & SOCK_DYNAMIC))
246                         gout=gout->next;
247                 
248                 if (gin && gout) {
249                         nsin = node_get_socket_stack(gstack, gin);
250                         nsout = node_get_socket_stack(gstack, gout);
251                         
252                         move_stack(nsin, nsout);
253                         
254                         gin=gin->next;
255                         gout=gout->next;
256                 }
257         }
258 }
259
260 static void forloop_execute(void *data, int thread, struct bNode *node, void *nodedata, struct bNodeStack **in, struct bNodeStack **out)
261 {
262         bNodeTreeExec *exec= (bNodeTreeExec*)nodedata;
263         int totiterations= (int)in[0]->vec[0];
264         bNodeSocket *sock;
265         bNodeStack *ns;
266         int iteration;
267         
268         /* XXX same behavior as trunk: all nodes inside group are executed.
269          * it's stupid, but just makes it work. compo redesign will do this better.
270          */
271         {
272                 bNode *inode;
273                 for (inode=exec->nodetree->nodes.first; inode; inode=inode->next)
274                         inode->need_exec = 1;
275         }
276         
277         /* "Iteration" socket */
278         sock = exec->nodetree->inputs.first;
279         ns = node_get_socket_stack(exec->stack, sock);
280         
281         group_copy_inputs(node, in, exec->stack);
282         for (iteration=0; iteration < totiterations; ++iteration) {
283                 /* first input contains current iteration counter */
284                 ns->vec[0] = (float)iteration;
285                 
286                 if (iteration > 0)
287                         loop_iteration_reset(exec->nodetree, exec->stack);
288                 ntreeExecNodes(exec, data, thread);
289                 group_free_internal(exec);
290         }
291         group_move_outputs(node, out, exec->stack);
292 }
293
294 void register_node_type_cmp_forloop(ListBase *lb)
295 {
296         static bNodeType ntype;
297
298         node_type_base(&ntype, NODE_FORLOOP, "For", NODE_CLASS_GROUP, NODE_OPTIONS);
299         node_type_socket_templates(&ntype, NULL, NULL);
300         node_type_size(&ntype, 120, 60, 200);
301         node_type_label(&ntype, node_group_label);
302         node_type_init(&ntype, node_forloop_init);
303         node_type_valid(&ntype, node_group_valid);
304         node_type_template(&ntype, node_forloop_template);
305         node_type_update(&ntype, NULL, node_group_verify);
306         node_type_tree(&ntype, node_forloop_init_tree, node_loop_update_tree);
307         node_type_group_edit(&ntype, node_group_edit_get, node_group_edit_set, node_group_edit_clear);
308         node_type_exec_new(&ntype, group_initexec, group_freeexec, forloop_execute);
309         
310         nodeRegisterType(lb, &ntype);
311 }
312 #endif
313
314
315 /**** WHILE LOOP ****/
316
317 #if 0 /* XXX loop nodes don't work nicely with current trees */
318 static void whileloop_execute(void *data, int thread, struct bNode *node, void *nodedata, struct bNodeStack **in, struct bNodeStack **out)
319 {
320         bNodeTreeExec *exec= (bNodeTreeExec*)nodedata;
321         int condition= (in[0]->vec[0] > 0.0f);
322         bNodeSocket *sock;
323         bNodeStack *ns;
324         int iteration;
325         
326         /* XXX same behavior as trunk: all nodes inside group are executed.
327          * it's stupid, but just makes it work. compo redesign will do this better.
328          */
329         {
330                 bNode *inode;
331                 for (inode=exec->nodetree->nodes.first; inode; inode=inode->next)
332                         inode->need_exec = 1;
333         }
334         
335         /* "Condition" socket */
336         sock = exec->nodetree->outputs.first;
337         ns = node_get_socket_stack(exec->stack, sock);
338         
339         iteration = 0;
340         group_copy_inputs(node, in, exec->stack);
341         while (condition && iteration < node->custom1) {
342                 if (iteration > 0)
343                         loop_iteration_reset(exec->nodetree, exec->stack);
344                 ntreeExecNodes(exec, data, thread);
345                 group_free_internal(exec);
346                 
347 //              PRINT_BUFFERS(exec);
348                 
349                 condition = (ns->vec[0] > 0.0f);
350                 ++iteration;
351         }
352         group_move_outputs(node, out, exec->stack);
353 }
354
355 void register_node_type_cmp_whileloop(ListBase *lb)
356 {
357         static bNodeType ntype;
358
359         node_type_base(&ntype, NODE_WHILELOOP, "While", NODE_CLASS_GROUP, NODE_OPTIONS);
360         node_type_socket_templates(&ntype, NULL, NULL);
361         node_type_size(&ntype, 120, 60, 200);
362         node_type_label(&ntype, node_group_label);
363         node_type_init(&ntype, node_whileloop_init);
364         node_type_valid(&ntype, node_group_valid);
365         node_type_template(&ntype, node_whileloop_template);
366         node_type_update(&ntype, NULL, node_group_verify);
367         node_type_tree(&ntype, node_whileloop_init_tree, node_loop_update_tree);
368         node_type_group_edit(&ntype, node_group_edit_get, node_group_edit_set, node_group_edit_clear);
369         node_type_exec_new(&ntype, group_initexec, group_freeexec, whileloop_execute);
370         
371         nodeRegisterType(lb, &ntype);
372 }
373 #endif