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