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