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