Merge branch 'blender2.7'
[blender.git] / source / blender / nodes / intern / node_util.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): Nathan Letwory.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/nodes/intern/node_util.c
29  *  \ingroup nodes
30  */
31
32 #include <ctype.h>
33 #include <limits.h>
34 #include <string.h>
35
36 #include "DNA_node_types.h"
37
38 #include "BLI_listbase.h"
39 #include "BLI_string.h"
40 #include "BLI_utildefines.h"
41
42 #include "BLT_translation.h"
43
44 #include "BKE_colortools.h"
45 #include "BKE_node.h"
46
47 #include "RNA_access.h"
48 #include "RNA_enum_types.h"
49
50 #include "MEM_guardedalloc.h"
51
52 #include "node_util.h"
53
54 /**** Storage Data ****/
55
56 void node_free_curves(bNode *node)
57 {
58         curvemapping_free(node->storage);
59 }
60
61 void node_free_standard_storage(bNode *node)
62 {
63         if (node->storage) {
64                 MEM_freeN(node->storage);
65         }
66 }
67
68 void node_copy_curves(bNodeTree *UNUSED(dest_ntree), bNode *dest_node, bNode *src_node)
69 {
70         dest_node->storage = curvemapping_copy(src_node->storage);
71 }
72
73 void node_copy_standard_storage(bNodeTree *UNUSED(dest_ntree), bNode *dest_node, bNode *src_node)
74 {
75         dest_node->storage = MEM_dupallocN(src_node->storage);
76 }
77
78 void *node_initexec_curves(bNodeExecContext *UNUSED(context), bNode *node, bNodeInstanceKey UNUSED(key))
79 {
80         curvemapping_initialize(node->storage);
81         return NULL;  /* unused return */
82 }
83
84
85 /**** Labels ****/
86
87 void node_blend_label(bNodeTree *UNUSED(ntree), bNode *node, char *label, int maxlen)
88 {
89         const char *name;
90         RNA_enum_name(rna_enum_ramp_blend_items, node->custom1, &name);
91         BLI_strncpy(label, IFACE_(name), maxlen);
92 }
93
94 void node_image_label(bNodeTree *UNUSED(ntree), bNode *node, char *label, int maxlen)
95 {
96         /* if there is no loaded image, return an empty string, and let nodeLabel() fill in the proper type translation. */
97         BLI_strncpy(label, (node->id) ? node->id->name + 2 : "", maxlen);
98 }
99
100 void node_math_label(bNodeTree *UNUSED(ntree), bNode *node, char *label, int maxlen)
101 {
102         const char *name;
103         RNA_enum_name(rna_enum_node_math_items, node->custom1, &name);
104         BLI_strncpy(label, IFACE_(name), maxlen);
105 }
106
107 void node_vect_math_label(bNodeTree *UNUSED(ntree), bNode *node, char *label, int maxlen)
108 {
109         const char *name;
110         RNA_enum_name(rna_enum_node_vec_math_items, node->custom1, &name);
111         BLI_strncpy(label, IFACE_(name), maxlen);
112 }
113
114 void node_filter_label(bNodeTree *UNUSED(ntree), bNode *node, char *label, int maxlen)
115 {
116         const char *name;
117         RNA_enum_name(rna_enum_node_filter_items, node->custom1, &name);
118         BLI_strncpy(label, IFACE_(name), maxlen);
119 }
120
121
122 /*** Link Insertion ***/
123
124 /* test if two sockets are interchangeable */
125 static bool node_link_socket_match(bNodeSocket *a, bNodeSocket *b)
126 {
127         /* check if sockets are of the same type */
128         if (a->typeinfo != b->typeinfo) {
129                 return false;
130         }
131
132         /* tests if alphabetic prefix matches
133          * this allows for imperfect matches, such as numeric suffixes,
134          * like Color1/Color2
135          */
136         int prefix_len = 0;
137         char *ca = a->name, *cb = b->name;
138         for (; *ca != '\0' && *cb != '\0'; ++ca, ++cb) {
139                 /* end of common prefix? */
140                 if (*ca != *cb) {
141                         /* prefix delimited by non-alphabetic char */
142                         if (isalpha(*ca) || isalpha(*cb))
143                                 return false;
144                         break;
145                 }
146                 ++prefix_len;
147         }
148         return prefix_len > 0;
149 }
150
151 static int node_count_links(bNodeTree *ntree, bNodeSocket *sock)
152 {
153         bNodeLink *link;
154         int count = 0;
155         for (link = ntree->links.first; link; link = link->next) {
156                 if (link->fromsock == sock)
157                         ++count;
158                 if (link->tosock == sock)
159                         ++count;
160         }
161         return count;
162 }
163
164 /* find an eligible socket for linking */
165 static bNodeSocket *node_find_linkable_socket(bNodeTree *ntree, bNode *node, bNodeSocket *cur)
166 {
167         /* link swapping: try to find a free slot with a matching name */
168
169         bNodeSocket *first = cur->in_out == SOCK_IN ? node->inputs.first : node->outputs.first;
170         bNodeSocket *sock;
171
172         sock = cur->next ? cur->next : first; /* wrap around the list end */
173         while (sock != cur) {
174                 if (!nodeSocketIsHidden(sock) && node_link_socket_match(sock, cur)) {
175                         int link_count = node_count_links(ntree, sock);
176                         /* take +1 into account since we would add a new link */
177                         if (link_count + 1 <= sock->limit)
178                                 return sock; /* found a valid free socket we can swap to */
179                 }
180
181                 sock = sock->next ? sock->next : first; /* wrap around the list end */
182         }
183         return NULL;
184 }
185
186 void node_insert_link_default(bNodeTree *ntree, bNode *node, bNodeLink *link)
187 {
188         bNodeSocket *sock = link->tosock;
189         bNodeLink *tlink, *tlink_next;
190
191         /* inputs can have one link only, outputs can have unlimited links */
192         if (node != link->tonode)
193                 return;
194
195         for (tlink = ntree->links.first; tlink; tlink = tlink_next) {
196                 bNodeSocket *new_sock;
197                 tlink_next = tlink->next;
198
199                 if (sock != tlink->tosock)
200                         continue;
201
202                 new_sock = node_find_linkable_socket(ntree, node, sock);
203                 if (new_sock && new_sock != sock) {
204                         /* redirect existing link */
205                         tlink->tosock = new_sock;
206                 }
207                 else if (!new_sock) {
208                         /* no possible replacement, remove tlink */
209                         nodeRemLink(ntree, tlink);
210                         tlink = NULL;
211                 }
212         }
213 }
214
215
216 /**** Internal Links (mute and disconnect) ****/
217
218 /* common datatype priorities, works for compositor, shader and texture nodes alike
219  * defines priority of datatype connection based on output type (to):
220  *   < 0  : never connect these types
221  *   >= 0 : priority of connection (higher values chosen first)
222  */
223 static int node_datatype_priority(eNodeSocketDatatype from, eNodeSocketDatatype to)
224 {
225         switch (to) {
226                 case SOCK_RGBA:
227                         switch (from) {
228                                 case SOCK_RGBA:     return 4;
229                                 case SOCK_FLOAT:    return 3;
230                                 case SOCK_INT:      return 2;
231                                 case SOCK_BOOLEAN:  return 1;
232                                 default: return -1;
233                         }
234                 case SOCK_VECTOR:
235                         switch (from) {
236                                 case SOCK_VECTOR:   return 4;
237                                 case SOCK_FLOAT:    return 3;
238                                 case SOCK_INT:      return 2;
239                                 case SOCK_BOOLEAN:  return 1;
240                                 default:            return -1;
241                         }
242                 case SOCK_FLOAT:
243                         switch (from) {
244                                 case SOCK_FLOAT:    return 5;
245                                 case SOCK_INT:      return 4;
246                                 case SOCK_BOOLEAN:  return 3;
247                                 case SOCK_RGBA:     return 2;
248                                 case SOCK_VECTOR:   return 1;
249                                 default:            return -1;
250                         }
251                 case SOCK_INT:
252                         switch (from) {
253                                 case SOCK_INT:      return 5;
254                                 case SOCK_FLOAT:    return 4;
255                                 case SOCK_BOOLEAN:  return 3;
256                                 case SOCK_RGBA:     return 2;
257                                 case SOCK_VECTOR:   return 1;
258                                 default:            return -1;
259                         }
260                 case SOCK_BOOLEAN:
261                         switch (from) {
262                                 case SOCK_BOOLEAN:  return 5;
263                                 case SOCK_INT:      return 4;
264                                 case SOCK_FLOAT:    return 3;
265                                 case SOCK_RGBA:     return 2;
266                                 case SOCK_VECTOR:   return 1;
267                                 default:            return -1;
268                         }
269                 case SOCK_SHADER:
270                         switch (from) {
271                                 case SOCK_SHADER:   return 1;
272                                 default:            return -1;
273                         }
274                 case SOCK_STRING:
275                         switch (from) {
276                                 case SOCK_STRING:   return 1;
277                                 default:            return -1;
278                         }
279                 default: return -1;
280         }
281 }
282
283 /* select a suitable input socket for an output */
284 static bNodeSocket *select_internal_link_input(bNode *node, bNodeSocket *output)
285 {
286         bNodeSocket *selected = NULL, *input;
287         int i;
288         int sel_priority = -1;
289         bool sel_is_linked = false;
290
291         for (input = node->inputs.first, i = 0; input; input = input->next, ++i) {
292                 int priority = node_datatype_priority(input->type, output->type);
293                 bool is_linked = (input->link != NULL);
294                 bool preferred;
295
296                 if (nodeSocketIsHidden(input) ||                /* ignore hidden sockets */
297                     input->flag & SOCK_NO_INTERNAL_LINK ||      /* ignore if input is not allowed for internal connections */
298                     priority < 0 ||                             /* ignore incompatible types */
299                     priority < sel_priority)                    /* ignore if we already found a higher priority input */
300                 {
301                         continue;
302                 }
303
304                 /* determine if this input is preferred over the currently selected */
305                 preferred = (priority > sel_priority) ||    /* prefer higher datatype priority */
306                             (is_linked && !sel_is_linked);  /* prefer linked over unlinked */
307
308                 if (preferred) {
309                         selected = input;
310                         sel_is_linked = is_linked;
311                         sel_priority = priority;
312                 }
313         }
314
315         return selected;
316 }
317
318 void node_update_internal_links_default(bNodeTree *ntree, bNode *node)
319 {
320         bNodeLink *link;
321         bNodeSocket *output, *input;
322
323         /* sanity check */
324         if (!ntree)
325                 return;
326
327         /* use link pointer as a tag for handled sockets (for outputs is unused anyway) */
328         for (output = node->outputs.first; output; output = output->next)
329                 output->link = NULL;
330
331         for (link = ntree->links.first; link; link = link->next) {
332                 if (nodeLinkIsHidden(link))
333                         continue;
334
335                 output = link->fromsock;
336                 if (link->fromnode != node || output->link)
337                         continue;
338                 if (nodeSocketIsHidden(output) || output->flag & SOCK_NO_INTERNAL_LINK)
339                         continue;
340                 output->link = link; /* not really used, just for tagging handled sockets */
341
342                 /* look for suitable input */
343                 input = select_internal_link_input(node, output);
344
345                 if (input) {
346                         bNodeLink *ilink = MEM_callocN(sizeof(bNodeLink), "internal node link");
347                         ilink->fromnode = node;
348                         ilink->fromsock = input;
349                         ilink->tonode = node;
350                         ilink->tosock = output;
351                         /* internal link is always valid */
352                         ilink->flag |= NODE_LINK_VALID;
353                         BLI_addtail(&node->internal_links, ilink);
354                 }
355         }
356
357         /* clean up */
358         for (output = node->outputs.first; output; output = output->next)
359                 output->link = NULL;
360 }
361
362
363 /**** Default value RNA access ****/
364
365 float node_socket_get_float(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock)
366 {
367         PointerRNA ptr;
368         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr);
369         return RNA_float_get(&ptr, "default_value");
370 }
371
372 void node_socket_set_float(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, float value)
373 {
374         PointerRNA ptr;
375         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr);
376         RNA_float_set(&ptr, "default_value", value);
377 }
378
379 void node_socket_get_color(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, float *value)
380 {
381         PointerRNA ptr;
382         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr);
383         RNA_float_get_array(&ptr, "default_value", value);
384 }
385
386 void node_socket_set_color(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, const float *value)
387 {
388         PointerRNA ptr;
389         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr);
390         RNA_float_set_array(&ptr, "default_value", value);
391 }
392
393 void node_socket_get_vector(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, float *value)
394 {
395         PointerRNA ptr;
396         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr);
397         RNA_float_get_array(&ptr, "default_value", value);
398 }
399
400 void node_socket_set_vector(bNodeTree *ntree, bNode *UNUSED(node), bNodeSocket *sock, const float *value)
401 {
402         PointerRNA ptr;
403         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr);
404         RNA_float_set_array(&ptr, "default_value", value);
405 }