Merge branch 'blender2.7'
[blender.git] / source / blender / nodes / intern / node_socket.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): Lukas Toennne
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/nodes/intern/node_socket.c
29  *  \ingroup nodes
30  */
31
32 #include <limits.h>
33
34 #include "DNA_node_types.h"
35
36 #include "BLI_listbase.h"
37 #include "BLI_math.h"
38 #include "BLI_utildefines.h"
39 #include "BLI_string.h"
40
41 #include "BKE_node.h"
42
43 #include "RNA_access.h"
44 #include "RNA_types.h"
45
46 #include "MEM_guardedalloc.h"
47
48 #include "NOD_socket.h"
49
50 struct Main;
51
52 struct bNodeSocket *node_add_socket_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp, int in_out)
53 {
54         bNodeSocket *sock = nodeAddStaticSocket(ntree, node, in_out, stemp->type, stemp->subtype, stemp->identifier, stemp->name);
55
56         sock->flag |= stemp->flag;
57
58         /* initialize default_value */
59         switch (stemp->type) {
60                 case SOCK_FLOAT:
61                 {
62                         bNodeSocketValueFloat *dval = sock->default_value;
63                         dval->value = stemp->val1;
64                         dval->min = stemp->min;
65                         dval->max = stemp->max;
66                         break;
67                 }
68                 case SOCK_INT:
69                 {
70                         bNodeSocketValueInt *dval = sock->default_value;
71                         dval->value = (int)stemp->val1;
72                         dval->min = (int)stemp->min;
73                         dval->max = (int)stemp->max;
74                         break;
75                 }
76                 case SOCK_BOOLEAN:
77                 {
78                         bNodeSocketValueBoolean *dval = sock->default_value;
79                         dval->value = (int)stemp->val1;
80                         break;
81                 }
82                 case SOCK_VECTOR:
83                 {
84                         bNodeSocketValueVector *dval = sock->default_value;
85                         dval->value[0] = stemp->val1;
86                         dval->value[1] = stemp->val2;
87                         dval->value[2] = stemp->val3;
88                         dval->min = stemp->min;
89                         dval->max = stemp->max;
90                         break;
91                 }
92                 case SOCK_RGBA:
93                 {
94                         bNodeSocketValueRGBA *dval = sock->default_value;
95                         dval->value[0] = stemp->val1;
96                         dval->value[1] = stemp->val2;
97                         dval->value[2] = stemp->val3;
98                         dval->value[3] = stemp->val4;
99                         break;
100                 }
101         }
102
103         return sock;
104 }
105
106 static bNodeSocket *verify_socket_template(bNodeTree *ntree, bNode *node, int in_out, ListBase *socklist, bNodeSocketTemplate *stemp)
107 {
108         bNodeSocket *sock;
109
110         for (sock = socklist->first; sock; sock = sock->next) {
111                 if (STREQLEN(sock->name, stemp->name, NODE_MAXSTR))
112                         break;
113         }
114         if (sock) {
115                 if (sock->type != stemp->type) {
116                         nodeModifySocketType(ntree, node, sock, stemp->type, stemp->subtype);
117                 }
118                 sock->limit = (stemp->limit == 0 ? (in_out == SOCK_IN ? 1 : 0xFFF) : stemp->limit);
119                 sock->flag |= stemp->flag;
120         }
121         else {
122                 /* no socket for this template found, make a new one */
123                 sock = node_add_socket_from_template(ntree, node, stemp, in_out);
124         }
125
126         /* remove the new socket from the node socket list first,
127          * will be added back after verification. */
128         BLI_remlink(socklist, sock);
129
130         return sock;
131 }
132
133 static void verify_socket_template_list(bNodeTree *ntree, bNode *node, int in_out, ListBase *socklist, bNodeSocketTemplate *stemp_first)
134 {
135         bNodeSocket *sock, *nextsock;
136         bNodeSocketTemplate *stemp;
137
138         /* no inputs anymore? */
139         if (stemp_first == NULL) {
140                 for (sock = (bNodeSocket *)socklist->first; sock; sock = nextsock) {
141                         nextsock = sock->next;
142                         nodeRemoveSocket(ntree, node, sock);
143                 }
144         }
145         else {
146                 /* step by step compare */
147                 stemp = stemp_first;
148                 while (stemp->type != -1) {
149                         stemp->sock = verify_socket_template(ntree, node, in_out, socklist, stemp);
150                         stemp++;
151                 }
152                 /* leftovers are removed */
153                 for (sock = (bNodeSocket *)socklist->first; sock; sock = nextsock) {
154                         nextsock = sock->next;
155                         nodeRemoveSocket(ntree, node, sock);
156                 }
157
158                 /* and we put back the verified sockets */
159                 stemp = stemp_first;
160                 if (socklist->first) {
161                         /* some dynamic sockets left, store the list start
162                          * so we can add static sockets infront of it.
163                          */
164                         sock = socklist->first;
165                         while (stemp->type != -1) {
166                                 /* put static sockets infront of dynamic */
167                                 BLI_insertlinkbefore(socklist, sock, stemp->sock);
168                                 stemp++;
169                         }
170                 }
171                 else {
172                         while (stemp->type != -1) {
173                                 BLI_addtail(socklist, stemp->sock);
174                                 stemp++;
175                         }
176                 }
177         }
178 }
179
180 void node_verify_socket_templates(bNodeTree *ntree, bNode *node)
181 {
182         bNodeType *ntype = node->typeinfo;
183         /* Don't try to match socket lists when there are no templates.
184          * This prevents dynamically generated sockets to be removed, like for
185          * group, image or render layer nodes. We have an explicit check for the
186          * render layer node since it still has fixed sockets too.
187          */
188         if (ntype) {
189                 if (ntype->inputs && ntype->inputs[0].type >= 0)
190                         verify_socket_template_list(ntree, node, SOCK_IN, &node->inputs, ntype->inputs);
191                 if (ntype->outputs && ntype->outputs[0].type >= 0 && node->type != CMP_NODE_R_LAYERS)
192                         verify_socket_template_list(ntree, node, SOCK_OUT, &node->outputs, ntype->outputs);
193         }
194 }
195
196
197 void node_socket_init_default_value(bNodeSocket *sock)
198 {
199         int type = sock->typeinfo->type;
200         int subtype = sock->typeinfo->subtype;
201
202         if (sock->default_value)
203                 return; /* already initialized */
204
205         switch (type) {
206                 case SOCK_FLOAT:
207                 {
208                         bNodeSocketValueFloat *dval = MEM_callocN(sizeof(bNodeSocketValueFloat), "node socket value float");
209                         dval->subtype = subtype;
210                         dval->value = 0.0f;
211                         dval->min = -FLT_MAX;
212                         dval->max = FLT_MAX;
213
214                         sock->default_value = dval;
215                         break;
216                 }
217                 case SOCK_INT:
218                 {
219                         bNodeSocketValueInt *dval = MEM_callocN(sizeof(bNodeSocketValueInt), "node socket value int");
220                         dval->subtype = subtype;
221                         dval->value = 0;
222                         dval->min = INT_MIN;
223                         dval->max = INT_MAX;
224
225                         sock->default_value = dval;
226                         break;
227                 }
228                 case SOCK_BOOLEAN:
229                 {
230                         bNodeSocketValueBoolean *dval = MEM_callocN(sizeof(bNodeSocketValueBoolean), "node socket value bool");
231                         dval->value = false;
232
233                         sock->default_value = dval;
234                         break;
235                 }
236                 case SOCK_VECTOR:
237                 {
238                         static float default_value[] = { 0.0f, 0.0f, 0.0f };
239                         bNodeSocketValueVector *dval = MEM_callocN(sizeof(bNodeSocketValueVector), "node socket value vector");
240                         dval->subtype = subtype;
241                         copy_v3_v3(dval->value, default_value);
242                         dval->min = -FLT_MAX;
243                         dval->max = FLT_MAX;
244
245                         sock->default_value = dval;
246                         break;
247                 }
248                 case SOCK_RGBA:
249                 {
250                         static float default_value[] = { 0.0f, 0.0f, 0.0f, 1.0f };
251                         bNodeSocketValueRGBA *dval = MEM_callocN(sizeof(bNodeSocketValueRGBA), "node socket value color");
252                         copy_v4_v4(dval->value, default_value);
253
254                         sock->default_value = dval;
255                         break;
256                 }
257                 case SOCK_STRING:
258                 {
259                         bNodeSocketValueString *dval = MEM_callocN(sizeof(bNodeSocketValueString), "node socket value string");
260                         dval->subtype = subtype;
261                         dval->value[0] = '\0';
262
263                         sock->default_value = dval;
264                         break;
265                 }
266         }
267 }
268
269 void node_socket_copy_default_value(bNodeSocket *to, const bNodeSocket *from)
270 {
271         /* sanity check */
272         if (to->type != from->type)
273                 return;
274
275         /* make sure both exist */
276         if (!from->default_value)
277                 return;
278         node_socket_init_default_value(to);
279
280         switch (from->typeinfo->type) {
281                 case SOCK_FLOAT:
282                 {
283                         bNodeSocketValueFloat *toval = to->default_value;
284                         bNodeSocketValueFloat *fromval = from->default_value;
285                         *toval = *fromval;
286                         break;
287                 }
288                 case SOCK_INT:
289                 {
290                         bNodeSocketValueInt *toval = to->default_value;
291                         bNodeSocketValueInt *fromval = from->default_value;
292                         *toval = *fromval;
293                         break;
294                 }
295                 case SOCK_BOOLEAN:
296                 {
297                         bNodeSocketValueBoolean *toval = to->default_value;
298                         bNodeSocketValueBoolean *fromval = from->default_value;
299                         *toval = *fromval;
300                         break;
301                 }
302                 case SOCK_VECTOR:
303                 {
304                         bNodeSocketValueVector *toval = to->default_value;
305                         bNodeSocketValueVector *fromval = from->default_value;
306                         *toval = *fromval;
307                         break;
308                 }
309                 case SOCK_RGBA:
310                 {
311                         bNodeSocketValueRGBA *toval = to->default_value;
312                         bNodeSocketValueRGBA *fromval = from->default_value;
313                         *toval = *fromval;
314                         break;
315                 }
316                 case SOCK_STRING:
317                 {
318                         bNodeSocketValueString *toval = to->default_value;
319                         bNodeSocketValueString *fromval = from->default_value;
320                         *toval = *fromval;
321                         break;
322                 }
323         }
324
325         to->flag |= (from->flag & SOCK_HIDE_VALUE);
326 }
327
328 static void standard_node_socket_interface_init_socket(bNodeTree *UNUSED(ntree), bNodeSocket *stemp, bNode *UNUSED(node), bNodeSocket *sock, const char *UNUSED(data_path))
329 {
330         /* initialize the type value */
331         sock->type = sock->typeinfo->type;
332
333         /* XXX socket interface 'type' value is not used really,
334          * but has to match or the copy function will bail out
335          */
336         stemp->type = stemp->typeinfo->type;
337         /* copy default_value settings */
338         node_socket_copy_default_value(sock, stemp);
339 }
340
341 /* copies settings that are not changed for each socket instance */
342 static void standard_node_socket_interface_verify_socket(bNodeTree *UNUSED(ntree), bNodeSocket *stemp, bNode *UNUSED(node), bNodeSocket *sock, const char *UNUSED(data_path))
343 {
344         /* sanity check */
345         if (sock->type != stemp->typeinfo->type)
346                 return;
347
348         /* make sure both exist */
349         if (!stemp->default_value)
350                 return;
351         node_socket_init_default_value(sock);
352
353         switch (stemp->typeinfo->type) {
354                 case SOCK_FLOAT:
355                 {
356                         bNodeSocketValueFloat *toval = sock->default_value;
357                         bNodeSocketValueFloat *fromval = stemp->default_value;
358                         toval->min = fromval->min;
359                         toval->max = fromval->max;
360                         break;
361                 }
362                 case SOCK_INT:
363                 {
364                         bNodeSocketValueInt *toval = sock->default_value;
365                         bNodeSocketValueInt *fromval = stemp->default_value;
366                         toval->min = fromval->min;
367                         toval->max = fromval->max;
368                         break;
369                 }
370                 case SOCK_VECTOR:
371                 {
372                         bNodeSocketValueVector *toval = sock->default_value;
373                         bNodeSocketValueVector *fromval = stemp->default_value;
374                         toval->min = fromval->min;
375                         toval->max = fromval->max;
376                         break;
377                 }
378         }
379 }
380
381 static void standard_node_socket_interface_from_socket(bNodeTree *UNUSED(ntree), bNodeSocket *stemp, bNode *UNUSED(node), bNodeSocket *sock)
382 {
383         /* initialize settings */
384         stemp->type = stemp->typeinfo->type;
385         node_socket_copy_default_value(stemp, sock);
386 }
387
388 static bNodeSocketType *make_standard_socket_type(int type, int subtype)
389 {
390         extern void ED_init_standard_node_socket_type(bNodeSocketType *);
391
392         const char *socket_idname = nodeStaticSocketType(type, subtype);
393         const char *interface_idname = nodeStaticSocketInterfaceType(type, subtype);
394         bNodeSocketType *stype;
395         StructRNA *srna;
396
397         stype = MEM_callocN(sizeof(bNodeSocketType), "node socket C type");
398         BLI_strncpy(stype->idname, socket_idname, sizeof(stype->idname));
399
400         /* set the RNA type
401          * uses the exact same identifier as the socket type idname */
402         srna = stype->ext_socket.srna = RNA_struct_find(socket_idname);
403         BLI_assert(srna != NULL);
404         /* associate the RNA type with the socket type */
405         RNA_struct_blender_type_set(srna, stype);
406
407         /* set the interface RNA type */
408         srna = stype->ext_interface.srna = RNA_struct_find(interface_idname);
409         BLI_assert(srna != NULL);
410         /* associate the RNA type with the socket type */
411         RNA_struct_blender_type_set(srna, stype);
412
413         /* extra type info for standard socket types */
414         stype->type = type;
415         stype->subtype = subtype;
416
417         /* XXX bad-level call! needed for setting draw callbacks */
418         ED_init_standard_node_socket_type(stype);
419
420         stype->interface_init_socket = standard_node_socket_interface_init_socket;
421         stype->interface_from_socket = standard_node_socket_interface_from_socket;
422         stype->interface_verify_socket = standard_node_socket_interface_verify_socket;
423
424         return stype;
425 }
426
427 static bNodeSocketType *make_socket_type_virtual(void)
428 {
429         extern void ED_init_node_socket_type_virtual(bNodeSocketType *);
430
431         const char *socket_idname = "NodeSocketVirtual";
432         bNodeSocketType *stype;
433         StructRNA *srna;
434
435         stype = MEM_callocN(sizeof(bNodeSocketType), "node socket C type");
436         BLI_strncpy(stype->idname, socket_idname, sizeof(stype->idname));
437
438         /* set the RNA type
439          * uses the exact same identifier as the socket type idname */
440         srna = stype->ext_socket.srna = RNA_struct_find(socket_idname);
441         BLI_assert(srna != NULL);
442         /* associate the RNA type with the socket type */
443         RNA_struct_blender_type_set(srna, stype);
444
445         /* extra type info for standard socket types */
446         stype->type = SOCK_CUSTOM;
447
448         ED_init_node_socket_type_virtual(stype);
449
450         return stype;
451 }
452
453
454 void register_standard_node_socket_types(void)
455 {
456         /* draw callbacks are set in drawnode.c to avoid bad-level calls */
457
458         nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_NONE));
459         nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_UNSIGNED));
460         nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_PERCENTAGE));
461         nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_FACTOR));
462         nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_ANGLE));
463         nodeRegisterSocketType(make_standard_socket_type(SOCK_FLOAT, PROP_TIME));
464
465         nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_NONE));
466         nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_UNSIGNED));
467         nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_PERCENTAGE));
468         nodeRegisterSocketType(make_standard_socket_type(SOCK_INT, PROP_FACTOR));
469
470         nodeRegisterSocketType(make_standard_socket_type(SOCK_BOOLEAN, PROP_NONE));
471
472         nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_NONE));
473         nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_TRANSLATION));
474         nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_DIRECTION));
475         nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_VELOCITY));
476         nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_ACCELERATION));
477         nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_EULER));
478         nodeRegisterSocketType(make_standard_socket_type(SOCK_VECTOR, PROP_XYZ));
479
480         nodeRegisterSocketType(make_standard_socket_type(SOCK_RGBA, PROP_NONE));
481
482         nodeRegisterSocketType(make_standard_socket_type(SOCK_STRING, PROP_NONE));
483
484         nodeRegisterSocketType(make_standard_socket_type(SOCK_SHADER, PROP_NONE));
485
486         nodeRegisterSocketType(make_socket_type_virtual());
487 }