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