Fix #28914: crash loading file saved with cycles builds in trunk.
[blender.git] / source / blender / nodes / intern / node_socket.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. 
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2007 Blender Foundation.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): Lukas Toennne
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 /** \file blender/nodes/intern/node_socket.c
31  *  \ingroup nodes
32  */
33
34
35 #include "DNA_node_types.h"
36
37 #include "DNA_mesh_types.h"
38 #include "DNA_meshdata_types.h"
39 #include "DNA_object_types.h"
40 #include "DNA_scene_types.h"
41
42 #include "BLI_listbase.h"
43 #include "BLI_math.h"
44 #include "BLI_utildefines.h"
45
46 #include "BKE_DerivedMesh.h"
47 #include "BKE_node.h"
48
49 #include "RNA_access.h"
50 #include "RNA_types.h"
51
52 #include "MEM_guardedalloc.h"
53
54 #include "NOD_socket.h"
55
56 /****************** FLOAT ******************/
57
58 static bNodeSocketType node_socket_type_float = {
59         /* type */                              SOCK_FLOAT,
60         /* ui_name */                   "Float",
61         /* ui_description */    "Floating Point",
62         /* ui_icon */                   0,
63         /* ui_color */                  {160,160,160,255},
64
65         /* value_structname */  "bNodeSocketValueFloat",
66         /* value_structsize */  sizeof(bNodeSocketValueFloat),
67
68         /* buttonfunc */                NULL,
69 };
70
71 /****************** VECTOR ******************/
72
73 static bNodeSocketType node_socket_type_vector = {
74         /* type */                              SOCK_VECTOR,
75         /* ui_name */                   "Vector",
76         /* ui_description */    "3-dimensional floating point vector",
77         /* ui_icon */                   0,
78         /* ui_color */                  {100,100,200,255},
79
80         /* value_structname */  "bNodeSocketValueVector",
81         /* value_structsize */  sizeof(bNodeSocketValueVector),
82
83         /* buttonfunc */                NULL,
84 };
85
86 /****************** RGBA ******************/
87
88 static bNodeSocketType node_socket_type_rgba = {
89         /* type */                              SOCK_RGBA,
90         /* ui_name */                   "RGBA",
91         /* ui_description */    "RGBA color",
92         /* ui_icon */                   0,
93         /* ui_color */                  {200,200,40,255},
94
95         /* value_structname */  "bNodeSocketValueRGBA",
96         /* value_structsize */  sizeof(bNodeSocketValueRGBA),
97
98         /* buttonfunc */                NULL,
99 };
100
101 /****************** INT ******************/
102
103 static bNodeSocketType node_socket_type_int = {
104         /* type */                              SOCK_INT,
105         /* ui_name */                   "Int",
106         /* ui_description */    "Integer",
107         /* ui_icon */                   0,
108         /* ui_color */                  {17,133,37,255},
109
110         /* value_structname */  "bNodeSocketValueInt",
111         /* value_structsize */  sizeof(bNodeSocketValueInt),
112
113         /* buttonfunc */                NULL,
114 };
115
116 /****************** BOOLEAN ******************/
117
118 static bNodeSocketType node_socket_type_boolean = {
119         /* type */                              SOCK_BOOLEAN,
120         /* ui_name */                   "Boolean",
121         /* ui_description */    "Boolean",
122         /* ui_icon */                   0,
123         /* ui_color */                  {158,139,63,255},
124
125         /* value_structname */  "bNodeSocketValueBoolean",
126         /* value_structsize */  sizeof(bNodeSocketValueBoolean),
127
128         /* buttonfunc */                NULL,
129 };
130
131 /****************** SHADER ******************/
132
133 static bNodeSocketType node_socket_type_shader = {
134         /* type */                              SOCK_SHADER,
135         /* ui_name */                   "Shader",
136         /* ui_description */    "Shader",
137         /* ui_icon */                   0,
138         /* ui_color */                  {100,200,100,255},
139
140         /* value_structname */  NULL,
141         /* value_structsize */  0,
142
143         /* buttonfunc */                NULL,
144 };
145
146 /****************** MESH ******************/
147
148 static bNodeSocketType node_socket_type_mesh = {
149         /* type */                              SOCK_MESH,
150         /* ui_name */                   "Mesh",
151         /* ui_description */    "Mesh geometry data",
152         /* ui_icon */                   0,
153         /* ui_color */                  {255,133,7,255},
154
155         /* value_structname */  NULL,
156         /* value_structsize */  0,
157
158         /* buttonfunc */                NULL,
159 };
160
161
162 void node_socket_type_init(bNodeSocketType *types[])
163 {
164         #define INIT_TYPE(name)         types[node_socket_type_##name.type] = &node_socket_type_##name;
165         
166         INIT_TYPE(float);
167         INIT_TYPE(vector);
168         INIT_TYPE(rgba);
169         INIT_TYPE(int);
170         INIT_TYPE(boolean);
171         INIT_TYPE(shader);
172         INIT_TYPE(mesh);
173         
174         #undef INIT_TYPE
175 }
176
177 struct bNodeSocket *nodeAddInputInt(struct bNodeTree *ntree, struct bNode *node, const char *name, PropertySubType subtype,
178                                                                         int value, int min, int max)
179 {
180         bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_IN, name, SOCK_INT);
181         bNodeSocketValueInt *dval= (bNodeSocketValueInt*)sock->default_value;
182         dval->subtype = subtype;
183         dval->value = value;
184         dval->min = min;
185         dval->max = max;
186         return sock;
187 }
188 struct bNodeSocket *nodeAddOutputInt(struct bNodeTree *ntree, struct bNode *node, const char *name)
189 {
190         bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_OUT, name, SOCK_INT);
191         return sock;
192 }
193
194 struct bNodeSocket *nodeAddInputFloat(struct bNodeTree *ntree, struct bNode *node, const char *name, PropertySubType subtype,
195                                                                           float value, float min, float max)
196 {
197         bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_IN, name, SOCK_FLOAT);
198         bNodeSocketValueFloat *dval= (bNodeSocketValueFloat*)sock->default_value;
199         dval->subtype = subtype;
200         dval->value = value;
201         dval->min = min;
202         dval->max = max;
203         return sock;
204 }
205 struct bNodeSocket *nodeAddOutputFloat(struct bNodeTree *ntree, struct bNode *node, const char *name)
206 {
207         bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_OUT, name, SOCK_FLOAT);
208         return sock;
209 }
210
211 struct bNodeSocket *nodeAddInputBoolean(struct bNodeTree *ntree, struct bNode *node, const char *name, char value)
212 {
213         bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_IN, name, SOCK_BOOLEAN);
214         bNodeSocketValueBoolean *dval= (bNodeSocketValueBoolean*)sock->default_value;
215         dval->value = value;
216         return sock;
217 }
218 struct bNodeSocket *nodeAddOutputBoolean(struct bNodeTree *ntree, struct bNode *node, const char *name)
219 {
220         bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_OUT, name, SOCK_BOOLEAN);
221         return sock;
222 }
223
224 struct bNodeSocket *nodeAddInputVector(struct bNodeTree *ntree, struct bNode *node, const char *name, PropertySubType subtype,
225                                                                            float x, float y, float z, float min, float max)
226 {
227         bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_IN, name, SOCK_VECTOR);
228         bNodeSocketValueVector *dval= (bNodeSocketValueVector*)sock->default_value;
229         dval->subtype = subtype;
230         dval->value[0] = x;
231         dval->value[1] = y;
232         dval->value[2] = z;
233         dval->min = min;
234         dval->max = max;
235         return sock;
236 }
237 struct bNodeSocket *nodeAddOutputVector(struct bNodeTree *ntree, struct bNode *node, const char *name)
238 {
239         bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_OUT, name, SOCK_VECTOR);
240         return sock;
241 }
242
243 struct bNodeSocket *nodeAddInputRGBA(struct bNodeTree *ntree, struct bNode *node, const char *name,
244                                                                          float r, float g, float b, float a)
245 {
246         bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_IN, name, SOCK_RGBA);
247         bNodeSocketValueRGBA *dval= (bNodeSocketValueRGBA*)sock->default_value;
248         dval->value[0] = r;
249         dval->value[1] = g;
250         dval->value[2] = b;
251         dval->value[3] = a;
252         return sock;
253 }
254 struct bNodeSocket *nodeAddOutputRGBA(struct bNodeTree *ntree, struct bNode *node, const char *name)
255 {
256         bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_OUT, name, SOCK_RGBA);
257         return sock;
258 }
259
260 struct bNodeSocket *nodeAddInputShader(struct bNodeTree *ntree, struct bNode *node, const char *name)
261 {
262         bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_IN, name, SOCK_SHADER);
263         return sock;
264 }
265 struct bNodeSocket *nodeAddOutputShader(struct bNodeTree *ntree, struct bNode *node, const char *name)
266 {
267         bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_OUT, name, SOCK_SHADER);
268         return sock;
269 }
270
271 struct bNodeSocket *nodeAddInputMesh(struct bNodeTree *ntree, struct bNode *node, const char *name)
272 {
273         bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_IN, name, SOCK_MESH);
274         return sock;
275 }
276 struct bNodeSocket *nodeAddOutputMesh(struct bNodeTree *ntree, struct bNode *node, const char *name)
277 {
278         bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_OUT, name, SOCK_MESH);
279         return sock;
280 }
281
282 struct bNodeSocket *node_add_input_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp)
283 {
284         bNodeSocket *sock;
285         switch (stemp->type) {
286         case SOCK_INT:
287                 sock = nodeAddInputInt(ntree, node, stemp->name, stemp->subtype, (int)stemp->val1, (int)stemp->min, (int)stemp->max);
288                 break;
289         case SOCK_FLOAT:
290                 sock = nodeAddInputFloat(ntree, node, stemp->name, stemp->subtype, stemp->val1, stemp->min, stemp->max);
291                 break;
292         case SOCK_BOOLEAN:
293                 sock = nodeAddInputBoolean(ntree, node, stemp->name, (char)stemp->val1);
294                 break;
295         case SOCK_VECTOR:
296                 sock = nodeAddInputVector(ntree, node, stemp->name, stemp->subtype, stemp->val1, stemp->val2, stemp->val3, stemp->min, stemp->max);
297                 break;
298         case SOCK_RGBA:
299                 sock = nodeAddInputRGBA(ntree, node, stemp->name, stemp->val1, stemp->val2, stemp->val3, stemp->val4);
300                 break;
301         case SOCK_SHADER:
302                 sock = nodeAddInputShader(ntree, node, stemp->name);
303                 break;
304         case SOCK_MESH:
305                 sock = nodeAddInputMesh(ntree, node, stemp->name);
306                 break;
307         default:
308                 sock = nodeAddSocket(ntree, node, SOCK_IN, stemp->name, stemp->type);
309         }
310         return sock;
311 }
312
313 struct bNodeSocket *node_add_output_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp)
314 {
315         bNodeSocket *sock;
316         switch (stemp->type) {
317         case SOCK_INT:
318                 sock = nodeAddOutputInt(ntree, node, stemp->name);
319                 break;
320         case SOCK_FLOAT:
321                 sock = nodeAddOutputFloat(ntree, node, stemp->name);
322                 break;
323         case SOCK_BOOLEAN:
324                 sock = nodeAddOutputBoolean(ntree, node, stemp->name);
325                 break;
326         case SOCK_VECTOR:
327                 sock = nodeAddOutputVector(ntree, node, stemp->name);
328                 break;
329         case SOCK_RGBA:
330                 sock = nodeAddOutputRGBA(ntree, node, stemp->name);
331                 break;
332         case SOCK_SHADER:
333                 sock = nodeAddOutputShader(ntree, node, stemp->name);
334                 break;
335         case SOCK_MESH:
336                 sock = nodeAddOutputMesh(ntree, node, stemp->name);
337                 break;
338         default:
339                 sock = nodeAddSocket(ntree, node, SOCK_OUT, stemp->name, stemp->type);
340         }
341         return sock;
342 }
343
344 static bNodeSocket *verify_socket_template(bNodeTree *ntree, bNode *node, int in_out, ListBase *socklist, bNodeSocketTemplate *stemp)
345 {
346         bNodeSocket *sock;
347         
348         for(sock= socklist->first; sock; sock= sock->next) {
349                 if(!(sock->flag & SOCK_DYNAMIC) && strncmp(sock->name, stemp->name, NODE_MAXSTR)==0)
350                         break;
351         }
352         if(sock) {
353                 sock->type= stemp->type;                /* in future, read this from tydefs! */
354                 if(stemp->limit==0) sock->limit= 0xFFF;
355                 else sock->limit= stemp->limit;
356                 
357                 /* Copy the property range and subtype parameters in case the template changed.
358                  * NOT copying the actual value here, only button behavior changes!
359                  */
360                 switch (sock->type) {
361                 case SOCK_FLOAT:
362                         {
363                                 bNodeSocketValueFloat *dval= sock->default_value;
364                                 dval->min = stemp->min;
365                                 dval->max = stemp->max;
366                                 dval->subtype = stemp->subtype;
367                         }
368                         break;
369                 case SOCK_INT:
370                         {
371                                 bNodeSocketValueInt *dval= sock->default_value;
372                                 dval->min = stemp->min;
373                                 dval->max = stemp->max;
374                                 dval->subtype = stemp->subtype;
375                         }
376                         break;
377                 case SOCK_VECTOR:
378                         {
379                                 bNodeSocketValueVector *dval= sock->default_value;
380                                 dval->min = stemp->min;
381                                 dval->max = stemp->max;
382                                 dval->subtype = stemp->subtype;
383                         }
384                         break;
385                 }
386                 
387                 BLI_remlink(socklist, sock);
388                 
389                 return sock;
390         }
391         else {
392                 /* no socket for this template found, make a new one */
393                 if (in_out==SOCK_IN)
394                         sock = node_add_input_from_template(ntree, node, stemp);
395                 else
396                         sock = node_add_output_from_template(ntree, node, stemp);
397                 /* remove the new socket from the node socket list first,
398                  * will be added back after verification.
399                  */
400                 BLI_remlink(socklist, sock);
401         }
402         
403         return sock;
404 }
405
406 static void verify_socket_template_list(bNodeTree *ntree, bNode *node, int in_out, ListBase *socklist, bNodeSocketTemplate *stemp_first)
407 {
408         bNodeSocket *sock;
409         bNodeSocketTemplate *stemp;
410         
411         /* no inputs anymore? */
412         if(stemp_first==NULL) {
413                 while(socklist->first) {
414                         sock = (bNodeSocket*)socklist->first;
415                         if (!(sock->flag & SOCK_DYNAMIC))
416                                 nodeRemoveSocket(ntree, node, socklist->first);
417                 }
418         }
419         else {
420                 /* step by step compare */
421                 stemp= stemp_first;
422                 while(stemp->type != -1) {
423                         stemp->sock= verify_socket_template(ntree, node, in_out, socklist, stemp);
424                         stemp++;
425                 }
426                 /* leftovers are removed */
427                 while(socklist->first) {
428                         sock = (bNodeSocket*)socklist->first;
429                         if (!(sock->flag & SOCK_DYNAMIC))
430                                 nodeRemoveSocket(ntree, node, socklist->first);
431                 }
432                 
433                 /* and we put back the verified sockets */
434                 stemp= stemp_first;
435                 if (socklist->first) {
436                         /* some dynamic sockets left, store the list start
437                          * so we can add static sockets infront of it.
438                          */
439                         sock = socklist->first;
440                         while(stemp->type != -1) {
441                                 /* put static sockets infront of dynamic */
442                                 BLI_insertlinkbefore(socklist, sock, stemp->sock);
443                                 stemp++;
444                         }
445                 }
446                 else {
447                         while(stemp->type != -1) {
448                                 BLI_addtail(socklist, stemp->sock);
449                                 stemp++;
450                         }
451                 }
452         }
453 }
454
455 void node_verify_socket_templates(bNodeTree *ntree, bNode *node)
456 {
457         bNodeType *ntype= node->typeinfo;
458         /* XXX Small trick: don't try to match socket lists when there are no templates.
459          * This also prevents group node sockets from being removed, without the need to explicitly
460          * check the node type here.
461          */
462         if(ntype && ((ntype->inputs && ntype->inputs[0].type>=0) || (ntype->outputs && ntype->outputs[0].type>=0))) {
463                 verify_socket_template_list(ntree, node, SOCK_IN, &node->inputs, ntype->inputs);
464                 verify_socket_template_list(ntree, node, SOCK_OUT, &node->outputs, ntype->outputs);
465         }
466 }