d0cb0b990efbd556bfb931e4dc6d1390bbbbe482
[blender-staging.git] / source / blender / makesrna / intern / rna_nodetree.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  * Contributor(s): Blender Foundation (2008), Nathan Letwory, Robin Allen, Bob Holcomb
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_nodetree.c
24  *  \ingroup RNA
25  */
26
27 #include <stdlib.h>
28 #include <string.h>
29 #include <limits.h>
30
31 #include "BLI_listbase.h"
32 #include "BLI_math.h"
33 #include "BLI_string.h"
34 #include "BLI_utildefines.h"
35
36 #include "BLF_translation.h"
37
38 #include "DNA_material_types.h"
39 #include "DNA_mesh_types.h"
40 #include "DNA_node_types.h"
41 #include "DNA_object_types.h"
42 #include "DNA_scene_types.h"
43 #include "DNA_text_types.h"
44 #include "DNA_texture_types.h"
45
46 #include "BKE_animsys.h"
47 #include "BKE_main.h"
48 #include "BKE_node.h"
49 #include "BKE_image.h"
50 #include "BKE_texture.h"
51 #include "BKE_idprop.h"
52
53 #include "RNA_access.h"
54 #include "RNA_define.h"
55 #include "RNA_enum_types.h"
56
57 #include "rna_internal.h"
58 #include "rna_internal_types.h"
59
60 #include "IMB_imbuf.h"
61 #include "IMB_imbuf_types.h"
62
63 #include "WM_types.h"
64
65 #include "MEM_guardedalloc.h"
66
67 EnumPropertyItem node_socket_in_out_items[] = {
68         { SOCK_IN, "IN", 0, "Input", "" },
69         { SOCK_OUT, "OUT", 0, "Output", "" },
70         { 0, NULL, 0, NULL, NULL }
71 };
72
73 #ifndef RNA_RUNTIME
74 static EnumPropertyItem node_socket_type_items[] = {
75         {SOCK_CUSTOM,  "CUSTOM",    0,    "Custom",    ""},
76         {SOCK_FLOAT,   "VALUE",     0,    "Value",     ""},
77         {SOCK_INT,     "INT",       0,    "Int",       ""},
78         {SOCK_BOOLEAN, "BOOLEAN",   0,    "Boolean",   ""},
79         {SOCK_VECTOR,  "VECTOR",    0,    "Vector",    ""},
80         {SOCK_STRING,  "STRING",    0,    "String",    ""},
81         {SOCK_RGBA,    "RGBA",      0,    "RGBA",      ""},
82         {SOCK_SHADER,  "SHADER",    0,    "Shader",    ""},
83         {0, NULL, 0, NULL, NULL}
84 };
85
86 static EnumPropertyItem node_quality_items[] = {
87         {NTREE_QUALITY_HIGH,   "HIGH",     0,    "High",     "High quality"},
88         {NTREE_QUALITY_MEDIUM, "MEDIUM",   0,    "Medium",   "Medium quality"},
89         {NTREE_QUALITY_LOW,    "LOW",      0,    "Low",      "Low quality"},
90         {0, NULL, 0, NULL, NULL}
91 };
92
93 static EnumPropertyItem node_chunksize_items[] = {
94         {NTREE_CHUNCKSIZE_32,   "32",     0,    "32x32",     "Chunksize of 32x32"},
95         {NTREE_CHUNCKSIZE_64,   "64",     0,    "64x64",     "Chunksize of 64x64"},
96         {NTREE_CHUNCKSIZE_128,  "128",    0,    "128x128",   "Chunksize of 128x128"},
97         {NTREE_CHUNCKSIZE_256,  "256",    0,    "256x256",   "Chunksize of 256x256"},
98         {NTREE_CHUNCKSIZE_512,  "512",    0,    "512x512",   "Chunksize of 512x512"},
99         {NTREE_CHUNCKSIZE_1024, "1024",   0,    "1024x1024", "Chunksize of 1024x1024"},
100         {0, NULL, 0, NULL, NULL}
101 };
102 #endif
103
104 #define DEF_ICON_BLANK_SKIP
105 #define DEF_ICON(name) {ICON_##name, (#name), 0, (#name), ""},
106 #define DEF_VICO(name)
107 EnumPropertyItem node_icon_items[] = {
108 #include "UI_icons.h"
109         {0, NULL, 0, NULL, NULL}};
110 #undef DEF_ICON_BLANK_SKIP
111 #undef DEF_ICON
112 #undef DEF_VICO
113
114 EnumPropertyItem node_math_items[] = {
115         {NODE_MATH_ADD,     "ADD",          0, "Add",          ""},
116         {NODE_MATH_SUB,     "SUBTRACT",     0, "Subtract",     ""},
117         {NODE_MATH_MUL,     "MULTIPLY",     0, "Multiply",     ""},
118         {NODE_MATH_DIVIDE,  "DIVIDE",       0, "Divide",       ""},
119         {NODE_MATH_SIN,     "SINE",         0, "Sine",         ""},
120         {NODE_MATH_COS,     "COSINE",       0, "Cosine",       ""},
121         {NODE_MATH_TAN,     "TANGENT",      0, "Tangent",      ""},
122         {NODE_MATH_ASIN,    "ARCSINE",      0, "Arcsine",      ""},
123         {NODE_MATH_ACOS,    "ARCCOSINE",    0, "Arccosine",    ""},
124         {NODE_MATH_ATAN,    "ARCTANGENT",   0, "Arctangent",   ""},
125         {NODE_MATH_POW,     "POWER",        0, "Power",        ""},
126         {NODE_MATH_LOG,     "LOGARITHM",    0, "Logarithm",    ""},
127         {NODE_MATH_MIN,     "MINIMUM",      0, "Minimum",      ""},
128         {NODE_MATH_MAX,     "MAXIMUM",      0, "Maximum",      ""},
129         {NODE_MATH_ROUND,   "ROUND",        0, "Round",        ""},
130         {NODE_MATH_LESS,    "LESS_THAN",    0, "Less Than",    ""},
131         {NODE_MATH_GREATER, "GREATER_THAN", 0, "Greater Than", ""},
132         {NODE_MATH_MOD,     "MODULO",       0, "Modulo",       ""},
133         {NODE_MATH_ABS,     "ABSOLUTE",     0, "Absolute",     ""},
134         {0, NULL, 0, NULL, NULL}
135 };
136
137 EnumPropertyItem node_vec_math_items[] = {
138         {0, "ADD",           0, "Add",           ""},
139         {1, "SUBTRACT",      0, "Subtract",      ""},
140         {2, "AVERAGE",       0, "Average",       ""},
141         {3, "DOT_PRODUCT",   0, "Dot Product",   ""},
142         {4, "CROSS_PRODUCT", 0, "Cross Product", ""},
143         {5, "NORMALIZE",     0, "Normalize",     ""},
144         {0, NULL, 0, NULL, NULL}
145 };
146
147 EnumPropertyItem node_filter_items[] = {
148         {0, "SOFTEN",  0, "Soften",  ""},
149         {1, "SHARPEN", 0, "Sharpen", ""},
150         {2, "LAPLACE", 0, "Laplace", ""},
151         {3, "SOBEL",   0, "Sobel",   ""},
152         {4, "PREWITT", 0, "Prewitt", ""},
153         {5, "KIRSCH",  0, "Kirsch",  ""},
154         {6, "SHADOW",  0, "Shadow",  ""},
155         {0, NULL, 0, NULL, NULL}
156 };
157
158 #ifndef RNA_RUNTIME
159 static EnumPropertyItem node_sampler_type_items[] = {
160         {0, "NEAREST",   0, "Nearest",   ""},
161         {1, "BILINEAR",   0, "Bilinear",   ""},
162         {2, "BICUBIC", 0, "Bicubic", ""},
163         {0, NULL, 0, NULL, NULL}
164 };
165 #endif
166
167 #ifdef RNA_RUNTIME
168
169 #include "BLI_linklist.h"
170 #include "BLI_string.h"
171
172 #include "BKE_context.h"
173 #include "BKE_idprop.h"
174 #include "BKE_library.h"
175
176 #include "BKE_global.h"
177
178 #include "ED_node.h"
179 #include "ED_render.h"
180
181 #include "NOD_common.h"
182 #include "NOD_socket.h"
183
184 #include "RE_engine.h"
185 #include "RE_pipeline.h"
186
187 #include "DNA_scene_types.h"
188 #include "WM_api.h"
189
190
191 int rna_node_tree_type_to_enum(bNodeTreeType *typeinfo)
192 {
193         int i = 0, result = -1;
194         NODE_TREE_TYPES_BEGIN (nt)
195         {
196                 if (nt == typeinfo) {
197                         result = i;
198                         break;
199                 }
200                 ++i;
201         }
202         NODE_TREE_TYPES_END;
203         return result;
204 }
205
206 int rna_node_tree_idname_to_enum(const char *idname)
207 {
208         int i = 0, result = -1;
209         NODE_TREE_TYPES_BEGIN (nt)
210         {
211                 if (STREQ(nt->idname, idname)) {
212                         result = i;
213                         break;
214                 }
215                 ++i;
216         }
217         NODE_TREE_TYPES_END;
218         return result;
219 }
220
221 bNodeTreeType *rna_node_tree_type_from_enum(int value)
222 {
223         int i = 0;
224         bNodeTreeType *result = NULL;
225         NODE_TREE_TYPES_BEGIN (nt)
226         {
227                 if (i == value) {
228                         result = nt;
229                         break;
230                 }
231                 ++i;
232         }
233         NODE_TREE_TYPES_END;
234         return result;
235 }
236
237 EnumPropertyItem *rna_node_tree_type_itemf(void *data, int (*poll)(void *data, bNodeTreeType *), bool *r_free)
238 {
239         EnumPropertyItem tmp = {0, "", 0, "", ""};
240         EnumPropertyItem *item = NULL;
241         int totitem = 0, i = 0;
242         
243         NODE_TREE_TYPES_BEGIN (nt)
244         {
245                 if (poll && !poll(data, nt)) {
246                         ++i;
247                         continue;
248                 }
249                 
250                 tmp.value = i;
251                 tmp.identifier = nt->idname;
252                 tmp.icon = nt->ui_icon;
253                 tmp.name = nt->ui_name;
254                 tmp.description = nt->ui_description;
255                 
256                 RNA_enum_item_add(&item, &totitem, &tmp);
257                 
258                 ++i;
259         }
260         NODE_TREE_TYPES_END;
261
262         RNA_enum_item_end(&item, &totitem);
263         *r_free = true;
264         
265         return item;
266 }
267
268 int rna_node_type_to_enum(bNodeType *typeinfo)
269 {
270         int i = 0, result = -1;
271         NODE_TYPES_BEGIN(ntype)
272                 if (ntype == typeinfo) {
273                         result = i;
274                         break;
275                 }
276                 ++i;
277         NODE_TYPES_END
278         return result;
279 }
280
281 int rna_node_idname_to_enum(const char *idname)
282 {
283         int i = 0, result = -1;
284         NODE_TYPES_BEGIN(ntype)
285                 if (STREQ(ntype->idname, idname)) {
286                         result = i;
287                         break;
288                 }
289                 ++i;
290         NODE_TYPES_END
291         return result;
292 }
293
294 bNodeType *rna_node_type_from_enum(int value)
295 {
296         int i = 0;
297         bNodeType *result = NULL;
298         NODE_TYPES_BEGIN(ntype)
299                 if (i == value) {
300                         result = ntype;
301                         break;
302                 }
303                 ++i;
304         NODE_TYPES_END
305         return result;
306 }
307
308 EnumPropertyItem *rna_node_type_itemf(void *data, int (*poll)(void *data, bNodeType *), bool *r_free)
309 {
310         EnumPropertyItem *item = NULL;
311         EnumPropertyItem tmp = {0, "", 0, "", ""};
312         int totitem = 0, i = 0;
313         
314         NODE_TYPES_BEGIN(ntype)
315                 if (poll && !poll(data, ntype)) {
316                         ++i;
317                         continue;
318                 }
319                 
320                 tmp.value = i;
321                 tmp.identifier = ntype->idname;
322                 tmp.icon = ntype->ui_icon;
323                 tmp.name = ntype->ui_name;
324                 tmp.description = ntype->ui_description;
325                 
326                 RNA_enum_item_add(&item, &totitem, &tmp);
327                 
328                 ++i;
329         NODE_TYPES_END
330         RNA_enum_item_end(&item, &totitem);
331         *r_free = true;
332         
333         return item;
334 }
335
336 int rna_node_socket_type_to_enum(bNodeSocketType *typeinfo)
337 {
338         int i = 0, result = -1;
339         NODE_SOCKET_TYPES_BEGIN(stype)
340                 if (stype == typeinfo) {
341                         result = i;
342                         break;
343                 }
344                 ++i;
345         NODE_SOCKET_TYPES_END
346         return result;
347 }
348
349 int rna_node_socket_idname_to_enum(const char *idname)
350 {
351         int i = 0, result = -1;
352         NODE_SOCKET_TYPES_BEGIN(stype)
353                 if (STREQ(stype->idname, idname)) {
354                         result = i;
355                         break;
356                 }
357                 ++i;
358         NODE_SOCKET_TYPES_END
359         return result;
360 }
361
362 bNodeSocketType *rna_node_socket_type_from_enum(int value)
363 {
364         int i = 0;
365         bNodeSocketType *result = NULL;
366         NODE_SOCKET_TYPES_BEGIN(stype)
367                 if (i == value) {
368                         result = stype;
369                         break;
370                 }
371                 ++i;
372         NODE_SOCKET_TYPES_END
373         return result;
374 }
375
376 EnumPropertyItem *rna_node_socket_type_itemf(void *data, int (*poll)(void *data, bNodeSocketType *), bool *r_free)
377 {
378         EnumPropertyItem *item = NULL;
379         EnumPropertyItem tmp = {0, "", 0, "", ""};
380         int totitem = 0, i = 0;
381         StructRNA *srna;
382         
383         NODE_SOCKET_TYPES_BEGIN(stype)
384                 if (poll && !poll(data, stype)) {
385                         ++i;
386                         continue;
387                 }
388                 
389                 srna = stype->ext_socket.srna;
390                 tmp.value = i;
391                 tmp.identifier = stype->idname;
392                 tmp.icon = RNA_struct_ui_icon(srna);
393                 tmp.name = RNA_struct_ui_name(srna);
394                 tmp.description = RNA_struct_ui_description(srna);
395                 
396                 RNA_enum_item_add(&item, &totitem, &tmp);
397                 
398                 ++i;
399         NODE_SOCKET_TYPES_END
400         RNA_enum_item_end(&item, &totitem);
401         *r_free = true;
402         
403         return item;
404 }
405
406 static EnumPropertyItem *rna_node_static_type_itemf(bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop), bool *r_free)
407 {
408         EnumPropertyItem *item = NULL;
409         EnumPropertyItem tmp;
410         int totitem = 0;
411         
412         /* hack, don't want to add include path to RNA just for this, since in the future RNA types
413          * for nodes should be defined locally at runtime anyway ...
414          */
415         
416         tmp.value = NODE_CUSTOM;
417         tmp.identifier = "CUSTOM";
418         tmp.name = "Custom";
419         tmp.description = "Custom Node";
420         tmp.icon = ICON_NONE;
421         RNA_enum_item_add(&item, &totitem, &tmp);
422         
423         tmp.value = NODE_UNDEFINED;
424         tmp.identifier = "UNDEFINED";
425         tmp.name = "UNDEFINED";
426         tmp.description = "";
427         tmp.icon = ICON_NONE;
428         RNA_enum_item_add(&item, &totitem, &tmp);
429         
430 #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
431         if (STREQ(#Category, "Node")) { \
432                 tmp.value = ID; \
433                 tmp.identifier = EnumName; \
434                 tmp.name = UIName; \
435                 tmp.description = UIDesc; \
436                 tmp.icon = ICON_NONE; \
437                 RNA_enum_item_add(&item, &totitem, &tmp); \
438         }
439 #include "../../nodes/NOD_static_types.h"
440 #undef DefNode
441         
442         if (RNA_struct_is_a(ptr->type, &RNA_ShaderNode)) {
443 #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
444                 if (STREQ(#Category, "ShaderNode")) { \
445                         tmp.value = ID; \
446                         tmp.identifier = EnumName; \
447                         tmp.name = UIName; \
448                         tmp.description = UIDesc; \
449                         tmp.icon = ICON_NONE; \
450                         RNA_enum_item_add(&item, &totitem, &tmp); \
451                 }
452 #include "../../nodes/NOD_static_types.h"
453 #undef DefNode
454         }
455
456         if (RNA_struct_is_a(ptr->type, &RNA_CompositorNode)) {
457 #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
458                 if (STREQ(#Category, "CompositorNode")) { \
459                         tmp.value = ID; \
460                         tmp.identifier = EnumName; \
461                         tmp.name = UIName; \
462                         tmp.description = UIDesc; \
463                         tmp.icon = ICON_NONE; \
464                         RNA_enum_item_add(&item, &totitem, &tmp); \
465                 }
466 #include "../../nodes/NOD_static_types.h"
467 #undef DefNode
468         }
469         
470         if (RNA_struct_is_a(ptr->type, &RNA_TextureNode)) {
471 #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
472                 if (STREQ(#Category, "TextureNode")) { \
473                         tmp.value = ID; \
474                         tmp.identifier = EnumName; \
475                         tmp.name = UIName; \
476                         tmp.description = UIDesc; \
477                         tmp.icon = ICON_NONE; \
478                         RNA_enum_item_add(&item, &totitem, &tmp); \
479                 }
480 #include "../../nodes/NOD_static_types.h"
481 #undef DefNode
482         }
483
484         RNA_enum_item_end(&item, &totitem);
485         *r_free = true;
486         
487         return item;
488 }
489
490 /* ******** Node Tree ******** */
491
492 static StructRNA *rna_NodeTree_refine(struct PointerRNA *ptr)
493 {
494         bNodeTree *ntree = (bNodeTree *)ptr->data;
495         
496         if (ntree->typeinfo->ext.srna)
497                 return ntree->typeinfo->ext.srna;
498         else
499                 return &RNA_NodeTree;
500 }
501
502 static int rna_NodeTree_poll(const bContext *C, bNodeTreeType *ntreetype)
503 {
504         extern FunctionRNA rna_NodeTree_poll_func;
505
506         PointerRNA ptr;
507         ParameterList list;
508         FunctionRNA *func;
509         void *ret;
510         int visible;
511
512         RNA_pointer_create(NULL, ntreetype->ext.srna, NULL, &ptr); /* dummy */
513         func = &rna_NodeTree_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */
514
515         RNA_parameter_list_create(&list, &ptr, func);
516         RNA_parameter_set_lookup(&list, "context", &C);
517         ntreetype->ext.call((bContext *)C, &ptr, func, &list);
518
519         RNA_parameter_get_lookup(&list, "visible", &ret);
520         visible = *(int *)ret;
521
522         RNA_parameter_list_free(&list);
523
524         return visible;
525 }
526
527 static void rna_NodeTree_update_reg(bNodeTree *ntree)
528 {
529         extern FunctionRNA rna_NodeTree_update_func;
530
531         PointerRNA ptr;
532         ParameterList list;
533         FunctionRNA *func;
534
535         RNA_id_pointer_create(&ntree->id, &ptr);
536         func = &rna_NodeTree_update_func; /* RNA_struct_find_function(&ptr, "update"); */
537
538         RNA_parameter_list_create(&list, &ptr, func);
539         ntree->typeinfo->ext.call(NULL, &ptr, func, &list);
540
541         RNA_parameter_list_free(&list);
542 }
543
544 static void rna_NodeTree_get_from_context(const bContext *C, bNodeTreeType *ntreetype,
545                                           bNodeTree **r_ntree, ID **r_id, ID **r_from)
546 {
547         extern FunctionRNA rna_NodeTree_get_from_context_func;
548
549         PointerRNA ptr;
550         ParameterList list;
551         FunctionRNA *func;
552         void *ret1, *ret2, *ret3;
553
554         RNA_pointer_create(NULL, ntreetype->ext.srna, NULL, &ptr); /* dummy */
555         func = &rna_NodeTree_get_from_context_func; /* RNA_struct_find_function(&ptr, "get_from_context"); */
556
557         RNA_parameter_list_create(&list, &ptr, func);
558         RNA_parameter_set_lookup(&list, "context", &C);
559         ntreetype->ext.call((bContext *)C, &ptr, func, &list);
560         
561         RNA_parameter_get_lookup(&list, "result_1", &ret1);
562         RNA_parameter_get_lookup(&list, "result_2", &ret2);
563         RNA_parameter_get_lookup(&list, "result_3", &ret3);
564         *r_ntree = *(bNodeTree **)ret1;
565         *r_id = *(ID **)ret2;
566         *r_from = *(ID **)ret3;
567
568         RNA_parameter_list_free(&list);
569 }
570
571 static void rna_NodeTree_unregister(Main *UNUSED(bmain), StructRNA *type)
572 {
573         bNodeTreeType *nt = RNA_struct_blender_type_get(type);
574
575         if (!nt)
576                 return;
577
578         RNA_struct_free_extension(type, &nt->ext);
579
580         ntreeTypeFreeLink(nt);
581
582         RNA_struct_free(&BLENDER_RNA, type);
583
584         /* update while blender is running */
585         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
586 }
587
588 static StructRNA *rna_NodeTree_register(
589         Main *bmain, ReportList *reports, void *data, const char *identifier,
590         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
591 {
592         bNodeTreeType *nt, dummynt;
593         bNodeTree dummyntree;
594         PointerRNA dummyptr;
595         int have_function[3];
596
597         /* setup dummy tree & tree type to store static properties in */
598         memset(&dummynt, 0, sizeof(bNodeTreeType));
599         memset(&dummyntree, 0, sizeof(bNodeTree));
600         dummyntree.typeinfo = &dummynt;
601         RNA_pointer_create(NULL, &RNA_NodeTree, &dummyntree, &dummyptr);
602
603         /* validate the python class */
604         if (validate(&dummyptr, data, have_function) != 0)
605                 return NULL;
606
607         if (strlen(identifier) >= sizeof(dummynt.idname)) {
608                 BKE_reportf(reports, RPT_ERROR, "Registering node tree class: '%s' is too long, maximum length is %d",
609                             identifier, (int)sizeof(dummynt.idname));
610                 return NULL;
611         }
612
613         /* check if we have registered this tree type before, and remove it */
614         nt = ntreeTypeFind(dummynt.idname);
615         if (nt)
616                 rna_NodeTree_unregister(bmain, nt->ext.srna);
617         
618         /* create a new node tree type */
619         nt = MEM_callocN(sizeof(bNodeTreeType), "node tree type");
620         memcpy(nt, &dummynt, sizeof(dummynt));
621
622         nt->type = NTREE_CUSTOM;
623
624         nt->ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, nt->idname, &RNA_NodeTree); 
625         nt->ext.data = data;
626         nt->ext.call = call;
627         nt->ext.free = free;
628         RNA_struct_blender_type_set(nt->ext.srna, nt);
629
630         RNA_def_struct_ui_text(nt->ext.srna, nt->ui_name, nt->ui_description);
631         RNA_def_struct_ui_icon(nt->ext.srna, nt->ui_icon);
632
633         nt->poll = (have_function[0]) ? rna_NodeTree_poll : NULL;
634         nt->update = (have_function[1]) ? rna_NodeTree_update_reg : NULL;
635         nt->get_from_context = (have_function[2]) ? rna_NodeTree_get_from_context : NULL;
636
637         ntreeTypeAdd(nt);
638
639         /* update while blender is running */
640         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
641         
642         return nt->ext.srna;
643 }
644
645 static bool rna_NodeTree_check(bNodeTree *ntree, ReportList *reports)
646 {
647         if (!ntreeIsRegistered(ntree)) {
648                 if (reports)
649                         BKE_reportf(reports, RPT_ERROR, "Node tree '%s' has undefined type %s", ntree->id.name + 2, ntree->idname);
650                 
651                 return false;
652         }
653         else
654                 return true;
655 }
656
657 static void rna_NodeTree_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
658 {
659         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
660
661         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
662         WM_main_add_notifier(NC_SCENE | ND_NODES, &ntree->id);
663
664         ED_node_tag_update_nodetree(bmain, ntree);
665 }
666
667 static bNode *rna_NodeTree_node_new(bNodeTree *ntree, bContext *C, ReportList *reports, const char *type)
668 {
669         bNodeType *ntype;
670         bNode *node;
671         
672         if (!rna_NodeTree_check(ntree, reports))
673                 return NULL;
674         
675         ntype = nodeTypeFind(type);
676         if (!ntype) {
677                 BKE_reportf(reports, RPT_ERROR, "Node type %s undefined", type);
678                 return NULL;
679         }
680         
681         if (ntype->poll && !ntype->poll(ntype, ntree)) {
682                 BKE_reportf(reports, RPT_ERROR, "Cannot add node of type %s to node tree '%s'", type, ntree->id.name + 2);
683                 return NULL;
684         }
685         
686         node = nodeAddNode(C, ntree, type);
687         BLI_assert(node && node->typeinfo);
688         
689         if (ntree->type == NTREE_TEXTURE) {
690                 ntreeTexCheckCyclics(ntree);
691         }
692         
693         ntreeUpdateTree(CTX_data_main(C), ntree);
694         nodeUpdate(ntree, node);
695         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
696
697         return node;
698 }
699
700 static void rna_NodeTree_node_remove(bNodeTree *ntree, ReportList *reports, PointerRNA *node_ptr)
701 {
702         bNode *node = node_ptr->data;
703         
704         if (!rna_NodeTree_check(ntree, reports))
705                 return;
706         
707         if (BLI_findindex(&ntree->nodes, node) == -1) {
708                 BKE_reportf(reports, RPT_ERROR, "Unable to locate node '%s' in node tree", node->name);
709                 return;
710         }
711
712         id_us_min(node->id);
713         nodeFreeNode(ntree, node);
714         RNA_POINTER_INVALIDATE(node_ptr);
715
716         ntreeUpdateTree(G.main, ntree); /* update group node socket links */
717         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
718 }
719
720 static void rna_NodeTree_node_clear(bNodeTree *ntree, ReportList *reports)
721 {
722         bNode *node = ntree->nodes.first;
723
724         if (!rna_NodeTree_check(ntree, reports))
725                 return;
726
727         while (node) {
728                 bNode *next_node = node->next;
729
730                 if (node->id)
731                         id_us_min(node->id);
732
733                 nodeFreeNode(ntree, node);
734
735                 node = next_node;
736         }
737
738         ntreeUpdateTree(G.main, ntree);
739
740         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
741 }
742
743 static PointerRNA rna_NodeTree_active_node_get(PointerRNA *ptr)
744 {
745         bNodeTree *ntree = (bNodeTree *)ptr->data;
746         bNode *node = nodeGetActive(ntree);
747         return rna_pointer_inherit_refine(ptr, &RNA_Node, node);
748 }
749
750 static void rna_NodeTree_active_node_set(PointerRNA *ptr, const PointerRNA value)
751 {
752         bNodeTree *ntree = (bNodeTree *)ptr->data;
753         bNode *node = (bNode *)value.data;
754         
755         if (node && BLI_findindex(&ntree->nodes, node) != -1)
756                 nodeSetActive(ntree, node);
757         else
758                 nodeClearActive(ntree);
759 }
760
761 static bNodeLink *rna_NodeTree_link_new(bNodeTree *ntree, ReportList *reports,
762                                         bNodeSocket *fromsock, bNodeSocket *tosock,
763                                         int verify_limits)
764 {
765         bNodeLink *ret;
766         bNode *fromnode = NULL, *tonode = NULL;
767
768         if (!rna_NodeTree_check(ntree, reports))
769                 return NULL;
770
771         nodeFindNode(ntree, fromsock, &fromnode, NULL);
772         nodeFindNode(ntree, tosock, &tonode, NULL);
773         /* check validity of the sockets:
774          * if sockets from different trees are passed in this will fail!
775          */
776         if (!fromnode || !tonode)
777                 return NULL;
778         
779         if (&fromsock->in_out == &tosock->in_out) {
780                 BKE_report(reports, RPT_ERROR, "Same input/output direction of sockets");
781                 return NULL;
782         }
783
784         if (verify_limits) {
785                 /* remove other socket links if limit is exceeded */
786                 if (nodeCountSocketLinks(ntree, fromsock) + 1 > fromsock->limit)
787                         nodeRemSocketLinks(ntree, fromsock);
788                 if (nodeCountSocketLinks(ntree, tosock) + 1 > tosock->limit)
789                         nodeRemSocketLinks(ntree, tosock);
790         }
791
792         ret = nodeAddLink(ntree, fromnode, fromsock, tonode, tosock);
793         
794         if (ret) {
795                 if (tonode)
796                         nodeUpdate(ntree, tonode);
797
798                 ntreeUpdateTree(G.main, ntree);
799
800                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
801         }
802         return ret;
803 }
804
805 static void rna_NodeTree_link_remove(bNodeTree *ntree, ReportList *reports, PointerRNA *link_ptr)
806 {
807         bNodeLink *link = link_ptr->data;
808
809         if (!rna_NodeTree_check(ntree, reports))
810                 return;
811
812         if (BLI_findindex(&ntree->links, link) == -1) {
813                 BKE_report(reports, RPT_ERROR, "Unable to locate link in node tree");
814                 return;
815         }
816
817         nodeRemLink(ntree, link);
818         RNA_POINTER_INVALIDATE(link_ptr);
819
820         ntreeUpdateTree(G.main, ntree);
821         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
822 }
823
824 static void rna_NodeTree_link_clear(bNodeTree *ntree, ReportList *reports)
825 {
826         bNodeLink *link = ntree->links.first;
827
828         if (!rna_NodeTree_check(ntree, reports))
829                 return;
830
831         while (link) {
832                 bNodeLink *next_link = link->next;
833
834                 nodeRemLink(ntree, link);
835
836                 link = next_link;
837         }
838         ntreeUpdateTree(G.main, ntree);
839
840         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
841 }
842
843 static int rna_NodeTree_active_input_get(PointerRNA *ptr)
844 {
845         bNodeTree *ntree = (bNodeTree *)ptr->data;
846         bNodeSocket *gsock;
847         int index;
848
849         for (gsock = ntree->inputs.first, index = 0; gsock; gsock = gsock->next, ++index)
850                 if (gsock->flag & SELECT)
851                         return index;
852         return -1;
853 }
854
855 static void rna_NodeTree_active_input_set(PointerRNA *ptr, int value)
856 {
857         bNodeTree *ntree = (bNodeTree *)ptr->data;
858         bNodeSocket *gsock;
859         int index;
860         
861         for (gsock = ntree->inputs.first, index = 0; gsock; gsock = gsock->next, ++index) {
862                 if (index == value)
863                         gsock->flag |= SELECT;
864                 else
865                         gsock->flag &= ~SELECT;
866         }
867         for (gsock = ntree->outputs.first; gsock; gsock = gsock->next) {
868                 gsock->flag &= ~SELECT;
869         }
870 }
871
872 static int rna_NodeTree_active_output_get(PointerRNA *ptr)
873 {
874         bNodeTree *ntree = (bNodeTree *)ptr->data;
875         bNodeSocket *gsock;
876         int index;
877
878         for (gsock = ntree->outputs.first, index = 0; gsock; gsock = gsock->next, ++index)
879                 if (gsock->flag & SELECT)
880                         return index;
881         return -1;
882 }
883
884 static void rna_NodeTree_active_output_set(PointerRNA *ptr, int value)
885 {
886         bNodeTree *ntree = (bNodeTree *)ptr->data;
887         bNodeSocket *gsock;
888         int index;
889         
890         for (gsock = ntree->inputs.first; gsock; gsock = gsock->next) {
891                 gsock->flag &= ~SELECT;
892         }
893         for (gsock = ntree->outputs.first, index = 0; gsock; gsock = gsock->next, ++index) {
894                 if (index == value)
895                         gsock->flag |= SELECT;
896                 else
897                         gsock->flag &= ~SELECT;
898         }
899 }
900
901 static bNodeSocket *rna_NodeTree_inputs_new(bNodeTree *ntree, ReportList *reports, const char *type, const char *name)
902 {
903         bNodeSocket *sock;
904         
905         if (!rna_NodeTree_check(ntree, reports))
906                 return NULL;
907         
908         sock = ntreeAddSocketInterface(ntree, SOCK_IN, type, name);
909         
910         ntreeUpdateTree(G.main, ntree);
911         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
912         
913         return sock;
914 }
915
916 static bNodeSocket *rna_NodeTree_outputs_new(bNodeTree *ntree, ReportList *reports, const char *type, const char *name)
917 {
918         bNodeSocket *sock;
919         
920         if (!rna_NodeTree_check(ntree, reports))
921                 return NULL;
922         
923         sock = ntreeAddSocketInterface(ntree, SOCK_OUT, type, name);
924         
925         ntreeUpdateTree(G.main, ntree);
926         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
927         
928         return sock;
929 }
930
931 static void rna_NodeTree_socket_remove(bNodeTree *ntree, ReportList *reports, bNodeSocket *sock)
932 {
933         if (!rna_NodeTree_check(ntree, reports))
934                 return;
935         
936         if (BLI_findindex(&ntree->inputs, sock) == -1 && BLI_findindex(&ntree->outputs, sock) == -1) {
937                 BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier);
938         }
939         else {
940                 ntreeRemoveSocketInterface(ntree, sock);
941                 
942                 ntreeUpdateTree(G.main, ntree);
943                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
944         }
945 }
946
947 static void rna_NodeTree_inputs_clear(bNodeTree *ntree, ReportList *reports)
948 {
949         bNodeSocket *sock, *nextsock;
950         
951         if (!rna_NodeTree_check(ntree, reports))
952                 return;
953         
954         for (sock = ntree->inputs.first; sock; sock = nextsock) {
955                 nextsock = sock->next;
956                 ntreeRemoveSocketInterface(ntree, sock);
957         }
958
959         ntreeUpdateTree(G.main, ntree);
960         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
961 }
962
963 static void rna_NodeTree_outputs_clear(bNodeTree *ntree, ReportList *reports)
964 {
965         bNodeSocket *sock, *nextsock;
966         
967         if (!rna_NodeTree_check(ntree, reports))
968                 return;
969         
970         for (sock = ntree->outputs.first; sock; sock = nextsock) {
971                 nextsock = sock->next;
972                 ntreeRemoveSocketInterface(ntree, sock);
973         }
974
975         ntreeUpdateTree(G.main, ntree);
976         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
977 }
978
979 static void rna_NodeTree_inputs_move(bNodeTree *ntree, int from_index, int to_index)
980 {
981         bNodeSocket *sock;
982         
983         if (from_index == to_index)
984                 return;
985         if (from_index < 0 || to_index < 0)
986                 return;
987         
988         sock = BLI_findlink(&ntree->inputs, from_index);
989         if (to_index < from_index) {
990                 bNodeSocket *nextsock = BLI_findlink(&ntree->inputs, to_index);
991                 if (nextsock) {
992                         BLI_remlink(&ntree->inputs, sock);
993                         BLI_insertlinkbefore(&ntree->inputs, nextsock, sock);
994                 }
995         }
996         else {
997                 bNodeSocket *prevsock = BLI_findlink(&ntree->inputs, to_index);
998                 if (prevsock) {
999                         BLI_remlink(&ntree->inputs, sock);
1000                         BLI_insertlinkafter(&ntree->inputs, prevsock, sock);
1001                 }
1002         }
1003         
1004         ntree->update |= NTREE_UPDATE_GROUP_IN;
1005         
1006         ntreeUpdateTree(G.main, ntree);
1007         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1008 }
1009
1010 static void rna_NodeTree_outputs_move(bNodeTree *ntree, int from_index, int to_index)
1011 {
1012         bNodeSocket *sock;
1013         
1014         if (from_index == to_index)
1015                 return;
1016         if (from_index < 0 || to_index < 0)
1017                 return;
1018         
1019         sock = BLI_findlink(&ntree->outputs, from_index);
1020         if (to_index < from_index) {
1021                 bNodeSocket *nextsock = BLI_findlink(&ntree->outputs, to_index);
1022                 if (nextsock) {
1023                         BLI_remlink(&ntree->outputs, sock);
1024                         BLI_insertlinkbefore(&ntree->outputs, nextsock, sock);
1025                 }
1026         }
1027         else {
1028                 bNodeSocket *prevsock = BLI_findlink(&ntree->outputs, to_index);
1029                 if (prevsock) {
1030                         BLI_remlink(&ntree->outputs, sock);
1031                         BLI_insertlinkafter(&ntree->outputs, prevsock, sock);
1032                 }
1033         }
1034         
1035         ntree->update |= NTREE_UPDATE_GROUP_OUT;
1036         
1037         ntreeUpdateTree(G.main, ntree);
1038         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1039 }
1040
1041 static void rna_NodeTree_interface_update(bNodeTree *ntree, bContext *C)
1042 {
1043         ntree->update |= NTREE_UPDATE_GROUP;
1044         ntreeUpdateTree(G.main, ntree);
1045         
1046         ED_node_tag_update_nodetree(CTX_data_main(C), ntree);
1047 }
1048
1049
1050 /* ******** NodeLink ******** */
1051
1052 static int rna_NodeLink_is_hidden_get(PointerRNA *ptr)
1053 {
1054         bNodeLink *link = ptr->data;
1055         return nodeLinkIsHidden(link);
1056 }
1057
1058
1059 /* ******** Node ******** */
1060
1061 static StructRNA *rna_Node_refine(struct PointerRNA *ptr)
1062 {
1063         bNode *node = (bNode *)ptr->data;
1064         
1065         if (node->typeinfo->ext.srna)
1066                 return node->typeinfo->ext.srna;
1067         else
1068                 return ptr->type;
1069 }
1070
1071 static char *rna_Node_path(PointerRNA *ptr)
1072 {
1073         bNode *node = (bNode *)ptr->data;
1074         char name_esc[sizeof(node->name) * 2];
1075
1076         BLI_strescape(name_esc, node->name, sizeof(name_esc));
1077         return BLI_sprintfN("nodes[\"%s\"]", name_esc);
1078 }
1079
1080 char *rna_Node_ImageUser_path(PointerRNA *ptr)
1081 {
1082         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1083         bNode *node;
1084         char name_esc[sizeof(node->name) * 2];
1085
1086         for (node = ntree->nodes.first; node; node = node->next) {
1087                 if (node->type == SH_NODE_TEX_ENVIRONMENT) {
1088                         NodeTexEnvironment *data = node->storage;
1089                         if (&data->iuser != ptr->data)
1090                                 continue;
1091                 }
1092                 else if (node->type == SH_NODE_TEX_IMAGE) {
1093                         NodeTexImage *data = node->storage;
1094                         if (&data->iuser != ptr->data)
1095                                 continue;
1096                 }
1097                 else
1098                         continue;
1099
1100                 BLI_strescape(name_esc, node->name, sizeof(name_esc));
1101                 return BLI_sprintfN("nodes[\"%s\"].image_user", name_esc);
1102         }
1103
1104         return NULL;
1105 }
1106
1107 static int rna_Node_poll(bNodeType *ntype, bNodeTree *ntree)
1108 {
1109         extern FunctionRNA rna_Node_poll_func;
1110
1111         PointerRNA ptr;
1112         ParameterList list;
1113         FunctionRNA *func;
1114         void *ret;
1115         int visible;
1116
1117         RNA_pointer_create(NULL, ntype->ext.srna, NULL, &ptr); /* dummy */
1118         func = &rna_Node_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */
1119
1120         RNA_parameter_list_create(&list, &ptr, func);
1121         RNA_parameter_set_lookup(&list, "node_tree", &ntree);
1122         ntype->ext.call(NULL, &ptr, func, &list);
1123
1124         RNA_parameter_get_lookup(&list, "visible", &ret);
1125         visible = *(int *)ret;
1126
1127         RNA_parameter_list_free(&list);
1128
1129         return visible;
1130 }
1131
1132 static int rna_Node_poll_instance(bNode *node, bNodeTree *ntree)
1133 {
1134         extern FunctionRNA rna_Node_poll_instance_func;
1135
1136         PointerRNA ptr;
1137         ParameterList list;
1138         FunctionRNA *func;
1139         void *ret;
1140         int visible;
1141
1142         RNA_pointer_create(NULL, node->typeinfo->ext.srna, node, &ptr); /* dummy */
1143         func = &rna_Node_poll_instance_func; /* RNA_struct_find_function(&ptr, "poll_instance"); */
1144
1145         RNA_parameter_list_create(&list, &ptr, func);
1146         RNA_parameter_set_lookup(&list, "node_tree", &ntree);
1147         node->typeinfo->ext.call(NULL, &ptr, func, &list);
1148
1149         RNA_parameter_get_lookup(&list, "visible", &ret);
1150         visible = *(int *)ret;
1151
1152         RNA_parameter_list_free(&list);
1153
1154         return visible;
1155 }
1156
1157 static int rna_Node_poll_instance_default(bNode *node, bNodeTree *ntree)
1158 {
1159         /* use the basic poll function */
1160         return rna_Node_poll(node->typeinfo, ntree);
1161 }
1162
1163 static void rna_Node_update_reg(bNodeTree *ntree, bNode *node)
1164 {
1165         extern FunctionRNA rna_Node_update_func;
1166
1167         PointerRNA ptr;
1168         ParameterList list;
1169         FunctionRNA *func;
1170
1171         RNA_pointer_create((ID *)ntree, node->typeinfo->ext.srna, node, &ptr);
1172         func = &rna_Node_update_func; /* RNA_struct_find_function(&ptr, "update"); */
1173
1174         RNA_parameter_list_create(&list, &ptr, func);
1175         node->typeinfo->ext.call(NULL, &ptr, func, &list);
1176
1177         RNA_parameter_list_free(&list);
1178 }
1179
1180 static void rna_Node_init(const bContext *C, PointerRNA *ptr)
1181 {
1182         extern FunctionRNA rna_Node_init_func;
1183
1184         bNode *node = (bNode *)ptr->data;
1185         ParameterList list;
1186         FunctionRNA *func;
1187
1188         func = &rna_Node_init_func; /* RNA_struct_find_function(&ptr, "init"); */
1189
1190         RNA_parameter_list_create(&list, ptr, func);
1191         node->typeinfo->ext.call((bContext *)C, ptr, func, &list);
1192
1193         RNA_parameter_list_free(&list);
1194 }
1195
1196 static void rna_Node_copy(PointerRNA *ptr, struct bNode *copynode)
1197 {
1198         extern FunctionRNA rna_Node_copy_func;
1199
1200         bNode *node = (bNode *)ptr->data;
1201         ParameterList list;
1202         FunctionRNA *func;
1203
1204         func = &rna_Node_copy_func; /* RNA_struct_find_function(&ptr, "copy"); */
1205
1206         RNA_parameter_list_create(&list, ptr, func);
1207         RNA_parameter_set_lookup(&list, "node", &copynode);
1208         node->typeinfo->ext.call(NULL, ptr, func, &list);
1209
1210         RNA_parameter_list_free(&list);
1211 }
1212
1213 static void rna_Node_free(PointerRNA *ptr)
1214 {
1215         extern FunctionRNA rna_Node_free_func;
1216
1217         bNode *node = (bNode *)ptr->data;
1218         ParameterList list;
1219         FunctionRNA *func;
1220
1221         func = &rna_Node_free_func; /* RNA_struct_find_function(&ptr, "free"); */
1222
1223         RNA_parameter_list_create(&list, ptr, func);
1224         node->typeinfo->ext.call(NULL, ptr, func, &list);
1225
1226         RNA_parameter_list_free(&list);
1227 }
1228
1229 static void rna_Node_draw_buttons(struct uiLayout *layout, bContext *C, PointerRNA *ptr)
1230 {
1231         extern FunctionRNA rna_Node_draw_buttons_func;
1232
1233         bNode *node = (bNode *)ptr->data;
1234         ParameterList list;
1235         FunctionRNA *func;
1236
1237         func = &rna_Node_draw_buttons_func; /* RNA_struct_find_function(&ptr, "draw_buttons"); */
1238
1239         RNA_parameter_list_create(&list, ptr, func);
1240         RNA_parameter_set_lookup(&list, "context", &C);
1241         RNA_parameter_set_lookup(&list, "layout", &layout);
1242         node->typeinfo->ext.call(C, ptr, func, &list);
1243
1244         RNA_parameter_list_free(&list);
1245 }
1246
1247 static void rna_Node_draw_buttons_ext(struct uiLayout *layout, bContext *C, PointerRNA *ptr)
1248 {
1249         extern FunctionRNA rna_Node_draw_buttons_ext_func;
1250
1251         bNode *node = (bNode *)ptr->data;
1252         ParameterList list;
1253         FunctionRNA *func;
1254
1255         func = &rna_Node_draw_buttons_ext_func; /* RNA_struct_find_function(&ptr, "draw_buttons_ext"); */
1256
1257         RNA_parameter_list_create(&list, ptr, func);
1258         RNA_parameter_set_lookup(&list, "context", &C);
1259         RNA_parameter_set_lookup(&list, "layout", &layout);
1260         node->typeinfo->ext.call(C, ptr, func, &list);
1261
1262         RNA_parameter_list_free(&list);
1263 }
1264
1265 static void rna_Node_draw_label(bNodeTree *ntree, bNode *node, char *label, int maxlen)
1266 {
1267         extern FunctionRNA rna_Node_draw_label_func;
1268
1269         PointerRNA ptr;
1270         ParameterList list;
1271         FunctionRNA *func;
1272         void *ret;
1273         char *rlabel;
1274
1275         func = &rna_Node_draw_label_func; /* RNA_struct_find_function(&ptr, "draw_label"); */
1276
1277         RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr);
1278         RNA_parameter_list_create(&list, &ptr, func);
1279         node->typeinfo->ext.call(NULL, &ptr, func, &list);
1280
1281         RNA_parameter_get_lookup(&list, "label", &ret);
1282         rlabel = *(char **)ret;
1283         BLI_strncpy(label, rlabel != NULL ? rlabel : "", maxlen);
1284
1285         RNA_parameter_list_free(&list);
1286 }
1287
1288 static int rna_Node_is_registered_node_type(StructRNA *type)
1289 {
1290         return (RNA_struct_blender_type_get(type) != NULL);
1291 }
1292
1293 static void rna_Node_is_registered_node_type_runtime(bContext *UNUSED(C), ReportList *UNUSED(reports), PointerRNA *ptr, ParameterList *parms)
1294 {
1295         int result = (RNA_struct_blender_type_get(ptr->type) != NULL);
1296         RNA_parameter_set_lookup(parms, "result", &result);
1297 }
1298
1299 static void rna_Node_unregister(Main *UNUSED(bmain), StructRNA *type)
1300 {
1301         bNodeType *nt = RNA_struct_blender_type_get(type);
1302
1303         if (!nt)
1304                 return;
1305
1306         RNA_struct_free_extension(type, &nt->ext);
1307
1308         /* this also frees the allocated nt pointer, no MEM_free call needed! */
1309         nodeUnregisterType(nt);
1310
1311         RNA_struct_free(&BLENDER_RNA, type);
1312
1313         /* update while blender is running */
1314         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1315 }
1316
1317 /* Generic internal registration function.
1318  * Can be used to implement callbacks for registerable RNA node subtypes.
1319  */
1320 static bNodeType *rna_Node_register_base(Main *bmain, ReportList *reports, StructRNA *basetype,
1321                                          void *data, const char *identifier,
1322                                          StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1323 {
1324         bNodeType *nt, dummynt;
1325         bNode dummynode;
1326         PointerRNA dummyptr;
1327         FunctionRNA *func;
1328         PropertyRNA *parm;
1329         int have_function[9];
1330
1331         /* setup dummy node & node type to store static properties in */
1332         memset(&dummynt, 0, sizeof(bNodeType));
1333         /* this does some additional initialization of default values */
1334         node_type_base_custom(&dummynt, identifier, "", 0, 0);
1335
1336         memset(&dummynode, 0, sizeof(bNode));
1337         dummynode.typeinfo = &dummynt;
1338         RNA_pointer_create(NULL, basetype, &dummynode, &dummyptr);
1339
1340         /* validate the python class */
1341         if (validate(&dummyptr, data, have_function) != 0)
1342                 return NULL;
1343
1344         if (strlen(identifier) >= sizeof(dummynt.idname)) {
1345                 BKE_reportf(reports, RPT_ERROR, "Registering node class: '%s' is too long, maximum length is %d",
1346                             identifier, (int)sizeof(dummynt.idname));
1347                 return NULL;
1348         }
1349
1350         /* check if we have registered this node type before, and remove it */
1351         nt = nodeTypeFind(dummynt.idname);
1352         if (nt)
1353                 rna_Node_unregister(bmain, nt->ext.srna);
1354         
1355         /* create a new node type */
1356         nt = MEM_callocN(sizeof(bNodeType), "node type");
1357         memcpy(nt, &dummynt, sizeof(dummynt));
1358         /* make sure the node type struct is freed on unregister */
1359         nt->needs_free = 1;
1360
1361         nt->ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, nt->idname, basetype);
1362         nt->ext.data = data;
1363         nt->ext.call = call;
1364         nt->ext.free = free;
1365         RNA_struct_blender_type_set(nt->ext.srna, nt);
1366
1367         RNA_def_struct_ui_text(nt->ext.srna, nt->ui_name, nt->ui_description);
1368         RNA_def_struct_ui_icon(nt->ext.srna, nt->ui_icon);
1369
1370         func = RNA_def_function_runtime(nt->ext.srna, "is_registered_node_type", rna_Node_is_registered_node_type_runtime);
1371         RNA_def_function_ui_description(func, "True if a registered node type");
1372         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_SELF_TYPE);
1373         parm = RNA_def_boolean(func, "result", false, "Result", "");
1374         RNA_def_function_return(func, parm);
1375
1376         /* XXX bad level call! needed to initialize the basic draw functions ... */
1377         ED_init_custom_node_type(nt);
1378
1379         nt->poll = (have_function[0]) ? rna_Node_poll : NULL;
1380         nt->poll_instance = (have_function[1]) ? rna_Node_poll_instance : rna_Node_poll_instance_default;
1381         nt->updatefunc = (have_function[2]) ? rna_Node_update_reg : NULL;
1382         nt->initfunc_api = (have_function[3]) ? rna_Node_init : NULL;
1383         nt->copyfunc_api = (have_function[4]) ? rna_Node_copy : NULL;
1384         nt->freefunc_api = (have_function[5]) ? rna_Node_free : NULL;
1385         nt->draw_buttons = (have_function[6]) ? rna_Node_draw_buttons : NULL;
1386         nt->draw_buttons_ex = (have_function[7]) ? rna_Node_draw_buttons_ext : NULL;
1387         nt->labelfunc = (have_function[8]) ? rna_Node_draw_label : NULL;
1388         
1389         /* sanitize size values in case not all have been registered */
1390         if (nt->maxwidth < nt->minwidth)
1391                 nt->maxwidth = nt->minwidth;
1392         if (nt->maxheight < nt->minheight)
1393                 nt->maxheight = nt->minheight;
1394         CLAMP(nt->width, nt->minwidth, nt->maxwidth);
1395         CLAMP(nt->height, nt->minheight, nt->maxheight);
1396         
1397         return nt;
1398 }
1399
1400 static StructRNA *rna_Node_register(
1401         Main *bmain, ReportList *reports,
1402         void *data, const char *identifier,
1403         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1404 {
1405         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_Node, data, identifier, validate, call, free);
1406         if (!nt)
1407                 return NULL;
1408         
1409         nodeRegisterType(nt);
1410         
1411         /* update while blender is running */
1412         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1413         
1414         return nt->ext.srna;
1415 }
1416
1417 static StructRNA *rna_ShaderNode_register(
1418         Main *bmain, ReportList *reports,
1419         void *data, const char *identifier,
1420         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1421 {
1422         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_ShaderNode, data, identifier, validate, call, free);
1423         if (!nt)
1424                 return NULL;
1425         
1426         nodeRegisterType(nt);
1427         
1428         /* update while blender is running */
1429         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1430         
1431         return nt->ext.srna;
1432 }
1433
1434 static StructRNA *rna_CompositorNode_register(
1435         Main *bmain, ReportList *reports,
1436         void *data, const char *identifier,
1437         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1438 {
1439         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_CompositorNode, data, identifier, validate, call, free);
1440         if (!nt)
1441                 return NULL;
1442         
1443         nodeRegisterType(nt);
1444         
1445         /* update while blender is running */
1446         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1447         
1448         return nt->ext.srna;
1449 }
1450
1451 static StructRNA *rna_TextureNode_register(
1452         Main *bmain, ReportList *reports,
1453         void *data, const char *identifier,
1454         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1455 {
1456         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_TextureNode, data, identifier, validate, call, free);
1457         if (!nt)
1458                 return NULL;
1459         
1460         nodeRegisterType(nt);
1461         
1462         /* update while blender is running */
1463         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1464         
1465         return nt->ext.srna;
1466 }
1467
1468 static IDProperty *rna_Node_idprops(PointerRNA *ptr, bool create)
1469 {
1470         bNode *node = ptr->data;
1471         
1472         if (create && !node->prop) {
1473                 IDPropertyTemplate val = {0};
1474                 node->prop = IDP_New(IDP_GROUP, &val, "RNA_Node ID properties");
1475         }
1476         
1477         return node->prop;
1478 }
1479
1480 static void rna_Node_parent_set(PointerRNA *ptr, PointerRNA value)
1481 {
1482         bNode *node = ptr->data;
1483         bNode *parent = value.data;
1484         
1485         if (parent) {
1486                 /* XXX only Frame node allowed for now,
1487                  * in the future should have a poll function or so to test possible attachment.
1488                  */
1489                 if (parent->type != NODE_FRAME)
1490                         return;
1491                 
1492                 /* make sure parent is not attached to the node */
1493                 if (nodeAttachNodeCheck(parent, node))
1494                         return;
1495         }
1496         
1497         nodeDetachNode(node);
1498         if (parent) {
1499                 nodeAttachNode(node, parent);
1500         }
1501 }
1502
1503 static int rna_Node_parent_poll(PointerRNA *ptr, PointerRNA value)
1504 {
1505         bNode *node = ptr->data;
1506         bNode *parent = value.data;
1507         
1508         /* XXX only Frame node allowed for now,
1509          * in the future should have a poll function or so to test possible attachment.
1510          */
1511         if (parent->type != NODE_FRAME)
1512                 return false;
1513         
1514         /* make sure parent is not attached to the node */
1515         if (nodeAttachNodeCheck(parent, node))
1516                 return false;
1517         
1518         return true;
1519 }
1520
1521 static void rna_Node_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
1522 {
1523         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1524         ED_node_tag_update_nodetree(bmain, ntree);
1525 }
1526
1527 static void rna_Node_socket_value_update(ID *id, bNode *UNUSED(node), bContext *C)
1528 {
1529         ED_node_tag_update_nodetree(CTX_data_main(C), (bNodeTree *)id);
1530 }
1531
1532 static void rna_Node_select_set(PointerRNA *ptr, int value)
1533 {
1534         bNode *node = (bNode *)ptr->data;
1535         nodeSetSelected(node, value);
1536 }
1537
1538 static void rna_Node_name_set(PointerRNA *ptr, const char *value)
1539 {
1540         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1541         bNode *node = (bNode *)ptr->data;
1542         char oldname[sizeof(node->name)];
1543         
1544         /* make a copy of the old name first */
1545         BLI_strncpy(oldname, node->name, sizeof(node->name));
1546         /* set new name */
1547         BLI_strncpy_utf8(node->name, value, sizeof(node->name));
1548         
1549         nodeUniqueName(ntree, node);
1550         
1551         /* fix all the animation data which may link to this */
1552         BKE_animdata_fix_paths_rename_all(NULL, "nodes", oldname, node->name);
1553 }
1554
1555 static bNodeSocket *rna_Node_inputs_new(ID *id, bNode *node, ReportList *reports, const char *type, const char *name, const char *identifier)
1556 {
1557         bNodeTree *ntree = (bNodeTree *)id;
1558         bNodeSocket *sock;
1559         
1560         sock = nodeAddSocket(ntree, node, SOCK_IN, type, identifier, name);
1561         
1562         if (sock == NULL) {
1563                 BKE_report(reports, RPT_ERROR, "Unable to create socket");
1564         }
1565         else {
1566                 ntreeUpdateTree(G.main, ntree);
1567                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1568         }
1569         
1570         return sock;
1571 }
1572
1573 static bNodeSocket *rna_Node_outputs_new(ID *id, bNode *node, ReportList *reports, const char *type, const char *name, const char *identifier)
1574 {
1575         bNodeTree *ntree = (bNodeTree *)id;
1576         bNodeSocket *sock;
1577         
1578         sock = nodeAddSocket(ntree, node, SOCK_OUT, type, identifier, name);
1579         
1580         if (sock == NULL) {
1581                 BKE_report(reports, RPT_ERROR, "Unable to create socket");
1582         }
1583         else {
1584                 ntreeUpdateTree(G.main, ntree);
1585                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1586         }
1587         
1588         return sock;
1589 }
1590
1591 static void rna_Node_socket_remove(ID *id, bNode *node, ReportList *reports, bNodeSocket *sock)
1592 {
1593         bNodeTree *ntree = (bNodeTree *)id;
1594         
1595         if (BLI_findindex(&node->inputs, sock) == -1 && BLI_findindex(&node->outputs, sock) == -1) {
1596                 BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier);
1597         }
1598         else {
1599                 nodeRemoveSocket(ntree, node, sock);
1600                 
1601                 ntreeUpdateTree(G.main, ntree);
1602                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1603         }
1604 }
1605
1606 static void rna_Node_inputs_clear(ID *id, bNode *node)
1607 {
1608         bNodeTree *ntree = (bNodeTree *)id;
1609         bNodeSocket *sock, *nextsock;
1610         
1611         for (sock = node->inputs.first; sock; sock = nextsock) {
1612                 nextsock = sock->next;
1613                 nodeRemoveSocket(ntree, node, sock);
1614         }
1615
1616         ntreeUpdateTree(G.main, ntree);
1617         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1618 }
1619
1620 static void rna_Node_outputs_clear(ID *id, bNode *node)
1621 {
1622         bNodeTree *ntree = (bNodeTree *)id;
1623         bNodeSocket *sock, *nextsock;
1624         
1625         for (sock = node->outputs.first; sock; sock = nextsock) {
1626                 nextsock = sock->next;
1627                 nodeRemoveSocket(ntree, node, sock);
1628         }
1629
1630         ntreeUpdateTree(G.main, ntree);
1631         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1632 }
1633
1634 static void rna_Node_inputs_move(ID *id, bNode *node, int from_index, int to_index)
1635 {
1636         bNodeTree *ntree = (bNodeTree *)id;
1637         bNodeSocket *sock;
1638         
1639         if (from_index == to_index)
1640                 return;
1641         if (from_index < 0 || to_index < 0)
1642                 return;
1643         
1644         sock = BLI_findlink(&node->inputs, from_index);
1645         if (to_index < from_index) {
1646                 bNodeSocket *nextsock = BLI_findlink(&node->inputs, to_index);
1647                 if (nextsock) {
1648                         BLI_remlink(&node->inputs, sock);
1649                         BLI_insertlinkbefore(&node->inputs, nextsock, sock);
1650                 }
1651         }
1652         else {
1653                 bNodeSocket *prevsock = BLI_findlink(&node->inputs, to_index);
1654                 if (prevsock) {
1655                         BLI_remlink(&node->inputs, sock);
1656                         BLI_insertlinkafter(&node->inputs, prevsock, sock);
1657                 }
1658         }
1659         
1660         ntreeUpdateTree(G.main, ntree);
1661         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1662 }
1663
1664 static void rna_Node_outputs_move(ID *id, bNode *node, int from_index, int to_index)
1665 {
1666         bNodeTree *ntree = (bNodeTree *)id;
1667         bNodeSocket *sock;
1668         
1669         if (from_index == to_index)
1670                 return;
1671         if (from_index < 0 || to_index < 0)
1672                 return;
1673         
1674         sock = BLI_findlink(&node->outputs, from_index);
1675         if (to_index < from_index) {
1676                 bNodeSocket *nextsock = BLI_findlink(&node->outputs, to_index);
1677                 if (nextsock) {
1678                         BLI_remlink(&node->outputs, sock);
1679                         BLI_insertlinkbefore(&node->outputs, nextsock, sock);
1680                 }
1681         }
1682         else {
1683                 bNodeSocket *prevsock = BLI_findlink(&node->outputs, to_index);
1684                 if (prevsock) {
1685                         BLI_remlink(&node->outputs, sock);
1686                         BLI_insertlinkafter(&node->outputs, prevsock, sock);
1687                 }
1688         }
1689         
1690         ntreeUpdateTree(G.main, ntree);
1691         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1692 }
1693
1694 static void rna_Node_width_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
1695 {
1696         bNode *node = ptr->data;
1697         *min = *softmin = node->typeinfo->minwidth;
1698         *max = *softmax = node->typeinfo->maxwidth;
1699 }
1700
1701 static void rna_Node_height_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
1702 {
1703         bNode *node = ptr->data;
1704         *min = *softmin = node->typeinfo->minheight;
1705         *max = *softmax = node->typeinfo->maxheight;
1706 }
1707
1708 static void rna_Node_dimensions_get(PointerRNA *ptr, float *value)
1709 {
1710         bNode *node = ptr->data;
1711         value[0] = node->totr.xmax - node->totr.xmin;
1712         value[1] = node->totr.ymax - node->totr.ymin;
1713 }
1714
1715
1716 /* ******** Node Socket ******** */
1717
1718 static void rna_NodeSocket_draw(bContext *C, struct uiLayout *layout, PointerRNA *ptr, PointerRNA *node_ptr, const char *text)
1719 {
1720         extern FunctionRNA rna_NodeSocket_draw_func;
1721
1722         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1723         ParameterList list;
1724         FunctionRNA *func;
1725
1726         func = &rna_NodeSocket_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
1727
1728         RNA_parameter_list_create(&list, ptr, func);
1729         RNA_parameter_set_lookup(&list, "context", &C);
1730         RNA_parameter_set_lookup(&list, "layout", &layout);
1731         RNA_parameter_set_lookup(&list, "node", node_ptr);
1732         RNA_parameter_set_lookup(&list, "text", &text);
1733         sock->typeinfo->ext_socket.call(C, ptr, func, &list);
1734
1735         RNA_parameter_list_free(&list);
1736 }
1737
1738 static void rna_NodeSocket_draw_color(bContext *C, PointerRNA *ptr, PointerRNA *node_ptr, float *r_color)
1739 {
1740         extern FunctionRNA rna_NodeSocket_draw_color_func;
1741
1742         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1743         ParameterList list;
1744         FunctionRNA *func;
1745         void *ret;
1746
1747         func = &rna_NodeSocket_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
1748
1749         RNA_parameter_list_create(&list, ptr, func);
1750         RNA_parameter_set_lookup(&list, "context", &C);
1751         RNA_parameter_set_lookup(&list, "node", node_ptr);
1752         sock->typeinfo->ext_socket.call(C, ptr, func, &list);
1753
1754         RNA_parameter_get_lookup(&list, "color", &ret);
1755         copy_v4_v4(r_color, (float *)ret);
1756
1757         RNA_parameter_list_free(&list);
1758 }
1759
1760 static void rna_NodeSocket_unregister(Main *UNUSED(bmain), StructRNA *type)
1761 {
1762         bNodeSocketType *st = RNA_struct_blender_type_get(type);
1763         if (!st)
1764                 return;
1765         
1766         RNA_struct_free_extension(type, &st->ext_socket);
1767
1768         nodeUnregisterSocketType(st);
1769
1770         RNA_struct_free(&BLENDER_RNA, type);
1771
1772         /* update while blender is running */
1773         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1774 }
1775
1776 static StructRNA *rna_NodeSocket_register(
1777         Main *UNUSED(bmain), ReportList *reports, void *data, const char *identifier,
1778         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1779 {
1780         bNodeSocketType *st, dummyst;
1781         bNodeSocket dummysock;
1782         PointerRNA dummyptr;
1783         int have_function[2];
1784
1785         /* setup dummy socket & socket type to store static properties in */
1786         memset(&dummyst, 0, sizeof(bNodeSocketType));
1787         
1788         memset(&dummysock, 0, sizeof(bNodeSocket));
1789         dummysock.typeinfo = &dummyst;
1790         RNA_pointer_create(NULL, &RNA_NodeSocket, &dummysock, &dummyptr);
1791
1792         /* validate the python class */
1793         if (validate(&dummyptr, data, have_function) != 0)
1794                 return NULL;
1795         
1796         if (strlen(identifier) >= sizeof(dummyst.idname)) {
1797                 BKE_reportf(reports, RPT_ERROR, "Registering node socket class: '%s' is too long, maximum length is %d",
1798                             identifier, (int)sizeof(dummyst.idname));
1799                 return NULL;
1800         }
1801
1802         /* check if we have registered this socket type before */
1803         st = nodeSocketTypeFind(dummyst.idname);
1804         if (!st) {
1805                 /* create a new node socket type */
1806                 st = MEM_callocN(sizeof(bNodeSocketType), "node socket type");
1807                 memcpy(st, &dummyst, sizeof(dummyst));
1808                 
1809                 nodeRegisterSocketType(st);
1810         }
1811         
1812         /* if RNA type is already registered, unregister first */
1813         if (st->ext_socket.srna) {
1814                 StructRNA *srna = st->ext_socket.srna;
1815                 RNA_struct_free_extension(srna, &st->ext_socket);
1816                 RNA_struct_free(&BLENDER_RNA, srna);
1817         }
1818         st->ext_socket.srna = RNA_def_struct_ptr(&BLENDER_RNA, st->idname, &RNA_NodeSocket); 
1819         st->ext_socket.data = data;
1820         st->ext_socket.call = call;
1821         st->ext_socket.free = free;
1822         RNA_struct_blender_type_set(st->ext_socket.srna, st);
1823         
1824         /* XXX bad level call! needed to initialize the basic draw functions ... */
1825         ED_init_custom_node_socket_type(st);
1826
1827         st->draw = (have_function[0]) ? rna_NodeSocket_draw : NULL;
1828         st->draw_color = (have_function[1]) ? rna_NodeSocket_draw_color : NULL;
1829
1830         /* update while blender is running */
1831         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1832         
1833         return st->ext_socket.srna;
1834 }
1835
1836 static StructRNA *rna_NodeSocket_refine(PointerRNA *ptr)
1837 {
1838         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1839         
1840         if (sock->typeinfo->ext_socket.srna)
1841                 return sock->typeinfo->ext_socket.srna;
1842         else
1843                 return &RNA_NodeSocket;
1844 }
1845
1846 static char *rna_NodeSocket_path(PointerRNA *ptr)
1847 {
1848         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1849         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1850         bNode *node;
1851         int socketindex;
1852         char name_esc[sizeof(node->name) * 2];
1853         
1854         if (!nodeFindNode(ntree, sock, &node, &socketindex))
1855                 return NULL;
1856         
1857         BLI_strescape(name_esc, node->name, sizeof(name_esc));
1858
1859         if (sock->in_out == SOCK_IN) {
1860                 return BLI_sprintfN("nodes[\"%s\"].inputs[%d]", name_esc, socketindex);
1861         }
1862         else {
1863                 return BLI_sprintfN("nodes[\"%s\"].outputs[%d]", name_esc, socketindex);
1864         }
1865 }
1866
1867 static IDProperty *rna_NodeSocket_idprops(PointerRNA *ptr, bool create)
1868 {
1869         bNodeSocket *sock = ptr->data;
1870         
1871         if (create && !sock->prop) {
1872                 IDPropertyTemplate val = {0};
1873                 sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocket ID properties");
1874         }
1875         
1876         return sock->prop;
1877 }
1878
1879 static PointerRNA rna_NodeSocket_node_get(PointerRNA *ptr)
1880 {
1881         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1882         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1883         bNode *node;
1884         PointerRNA r_ptr;
1885         
1886         nodeFindNode(ntree, sock, &node, NULL);
1887         
1888         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &r_ptr);
1889         return r_ptr;
1890 }
1891
1892 static void rna_NodeSocket_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
1893 {
1894         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1895         ED_node_tag_update_nodetree(bmain, ntree);
1896 }
1897
1898 static int rna_NodeSocket_is_output_get(PointerRNA *ptr)
1899 {
1900         bNodeSocket *sock = ptr->data;
1901         return sock->in_out == SOCK_OUT;
1902 }
1903
1904 static void rna_NodeSocket_link_limit_set(PointerRNA *ptr, int value)
1905 {
1906         bNodeSocket *sock = ptr->data;
1907         sock->limit = (value == 0 ? 0xFFF : value);
1908 }
1909
1910 static void rna_NodeSocket_hide_set(PointerRNA *ptr, int value)
1911 {
1912         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1913         
1914         /* don't hide linked sockets */
1915         if (sock->flag & SOCK_IN_USE)
1916                 return;
1917         
1918         if (value)
1919                 sock->flag |= SOCK_HIDDEN;
1920         else
1921                 sock->flag &= ~SOCK_HIDDEN;
1922 }
1923
1924
1925 static void rna_NodeSocketInterface_draw(bContext *C, struct uiLayout *layout, PointerRNA *ptr)
1926 {
1927         extern FunctionRNA rna_NodeSocketInterface_draw_func;
1928
1929         bNodeSocket *stemp = (bNodeSocket *)ptr->data;
1930         ParameterList list;
1931         FunctionRNA *func;
1932
1933         if (!stemp->typeinfo)
1934                 return;
1935
1936         func = &rna_NodeSocketInterface_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
1937
1938         RNA_parameter_list_create(&list, ptr, func);
1939         RNA_parameter_set_lookup(&list, "context", &C);
1940         RNA_parameter_set_lookup(&list, "layout", &layout);
1941         stemp->typeinfo->ext_interface.call(C, ptr, func, &list);
1942
1943         RNA_parameter_list_free(&list);
1944 }
1945
1946 static void rna_NodeSocketInterface_draw_color(bContext *C, PointerRNA *ptr, float *r_color)
1947 {
1948         extern FunctionRNA rna_NodeSocketInterface_draw_color_func;
1949
1950         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1951         ParameterList list;
1952         FunctionRNA *func;
1953         void *ret;
1954
1955         if (!sock->typeinfo)
1956                 return;
1957
1958         func = &rna_NodeSocketInterface_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
1959
1960         RNA_parameter_list_create(&list, ptr, func);
1961         RNA_parameter_set_lookup(&list, "context", &C);
1962         sock->typeinfo->ext_interface.call(C, ptr, func, &list);
1963
1964         RNA_parameter_get_lookup(&list, "color", &ret);
1965         copy_v4_v4(r_color, (float *)ret);
1966
1967         RNA_parameter_list_free(&list);
1968 }
1969
1970 static void rna_NodeSocketInterface_register_properties(bNodeTree *ntree, bNodeSocket *stemp, StructRNA *data_srna)
1971 {
1972         extern FunctionRNA rna_NodeSocketInterface_register_properties_func;
1973
1974         PointerRNA ptr;
1975         ParameterList list;
1976         FunctionRNA *func;
1977
1978         if (!stemp->typeinfo)
1979                 return;
1980
1981         RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
1982         func = &rna_NodeSocketInterface_register_properties_func; /* RNA_struct_find_function(&ptr, "register_properties"); */
1983
1984         RNA_parameter_list_create(&list, &ptr, func);
1985         RNA_parameter_set_lookup(&list, "data_rna_type", &data_srna);
1986         stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
1987
1988         RNA_parameter_list_free(&list);
1989 }
1990
1991 static void rna_NodeSocketInterface_init_socket(bNodeTree *ntree, bNodeSocket *stemp, bNode *node, bNodeSocket *sock, const char *data_path)
1992 {
1993         extern FunctionRNA rna_NodeSocketInterface_init_socket_func;
1994
1995         PointerRNA ptr, node_ptr, sock_ptr;
1996         ParameterList list;
1997         FunctionRNA *func;
1998
1999         if (!stemp->typeinfo)
2000                 return;
2001
2002         RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
2003         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
2004         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr);
2005         func = &rna_NodeSocketInterface_init_socket_func; /* RNA_struct_find_function(&ptr, "init_socket"); */
2006
2007         RNA_parameter_list_create(&list, &ptr, func);
2008         RNA_parameter_set_lookup(&list, "node", &node_ptr);
2009         RNA_parameter_set_lookup(&list, "socket", &sock_ptr);
2010         RNA_parameter_set_lookup(&list, "data_path", &data_path);
2011         stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2012
2013         RNA_parameter_list_free(&list);
2014 }
2015
2016 static void rna_NodeSocketInterface_from_socket(bNodeTree *ntree, bNodeSocket *stemp, bNode *node, bNodeSocket *sock)
2017 {
2018         extern FunctionRNA rna_NodeSocketInterface_from_socket_func;
2019
2020         PointerRNA ptr, node_ptr, sock_ptr;
2021         ParameterList list;
2022         FunctionRNA *func;
2023
2024         if (!stemp->typeinfo)
2025                 return;
2026
2027         RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
2028         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
2029         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr);
2030         func = &rna_NodeSocketInterface_from_socket_func; /* RNA_struct_find_function(&ptr, "from_socket"); */
2031
2032         RNA_parameter_list_create(&list, &ptr, func);
2033         RNA_parameter_set_lookup(&list, "node", &node_ptr);
2034         RNA_parameter_set_lookup(&list, "socket", &sock_ptr);
2035         stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2036
2037         RNA_parameter_list_free(&list);
2038 }
2039
2040 static void rna_NodeSocketInterface_unregister(Main *UNUSED(bmain), StructRNA *type)
2041 {
2042         bNodeSocketType *st = RNA_struct_blender_type_get(type);
2043         if (!st)
2044                 return;
2045         
2046         RNA_struct_free_extension(type, &st->ext_interface);
2047         
2048         RNA_struct_free(&BLENDER_RNA, type);
2049         
2050         /* update while blender is running */
2051         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2052 }
2053
2054 static StructRNA *rna_NodeSocketInterface_register(
2055         Main *UNUSED(bmain), ReportList *UNUSED(reports), void *data, const char *identifier,
2056         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
2057 {
2058         bNodeSocketType *st, dummyst;
2059         bNodeSocket dummysock;
2060         PointerRNA dummyptr;
2061         int have_function[5];
2062
2063         /* setup dummy socket & socket type to store static properties in */
2064         memset(&dummyst, 0, sizeof(bNodeSocketType));
2065         
2066         memset(&dummysock, 0, sizeof(bNodeSocket));
2067         dummysock.typeinfo = &dummyst;
2068         RNA_pointer_create(NULL, &RNA_NodeSocketInterface, &dummysock, &dummyptr);
2069
2070         /* validate the python class */
2071         if (validate(&dummyptr, data, have_function) != 0)
2072                 return NULL;
2073
2074         /* check if we have registered this socket type before */
2075         st = nodeSocketTypeFind(dummyst.idname);
2076         if (st) {
2077                 /* basic socket type registered by a socket class before. */
2078         }
2079         else {
2080                 /* create a new node socket type */
2081                 st = MEM_callocN(sizeof(bNodeSocketType), "node socket type");
2082                 memcpy(st, &dummyst, sizeof(dummyst));
2083                 
2084                 nodeRegisterSocketType(st);
2085         }
2086         
2087         /* if RNA type is already registered, unregister first */
2088         if (st->ext_interface.srna) {
2089                 StructRNA *srna = st->ext_interface.srna;
2090                 RNA_struct_free_extension(srna, &st->ext_interface);
2091                 RNA_struct_free(&BLENDER_RNA, srna);
2092         }
2093         st->ext_interface.srna = RNA_def_struct_ptr(&BLENDER_RNA, identifier, &RNA_NodeSocketInterface); 
2094         st->ext_interface.data = data;
2095         st->ext_interface.call = call;
2096         st->ext_interface.free = free;
2097         RNA_struct_blender_type_set(st->ext_interface.srna, st);
2098         
2099         st->interface_draw = (have_function[0]) ? rna_NodeSocketInterface_draw : NULL;
2100         st->interface_draw_color = (have_function[1]) ? rna_NodeSocketInterface_draw_color : NULL;
2101         st->interface_register_properties = (have_function[2]) ? rna_NodeSocketInterface_register_properties : NULL;
2102         st->interface_init_socket = (have_function[3]) ? rna_NodeSocketInterface_init_socket : NULL;
2103         st->interface_from_socket = (have_function[4]) ? rna_NodeSocketInterface_from_socket : NULL;
2104         
2105         /* update while blender is running */
2106         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2107         
2108         return st->ext_interface.srna;
2109 }
2110
2111 static StructRNA *rna_NodeSocketInterface_refine(PointerRNA *ptr)
2112 {
2113         bNodeSocket *sock = (bNodeSocket *)ptr->data;
2114         
2115         if (sock->typeinfo && sock->typeinfo->ext_interface.srna)
2116                 return sock->typeinfo->ext_interface.srna;
2117         else
2118                 return &RNA_NodeSocketInterface;
2119 }
2120
2121 static char *rna_NodeSocketInterface_path(PointerRNA *ptr)
2122 {
2123         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2124         bNodeSocket *sock = (bNodeSocket *)ptr->data;
2125         int socketindex;
2126         
2127         socketindex = BLI_findindex(&ntree->inputs, sock);
2128         if (socketindex != -1)
2129                 return BLI_sprintfN("inputs[%d]", socketindex);
2130         
2131         socketindex = BLI_findindex(&ntree->outputs, sock);
2132         if (socketindex != -1)
2133                 return BLI_sprintfN("outputs[%d]", socketindex);
2134         
2135         return NULL;
2136 }
2137
2138 static IDProperty *rna_NodeSocketInterface_idprops(PointerRNA *ptr, bool create)
2139 {
2140         bNodeSocket *sock = ptr->data;
2141         
2142         if (create && !sock->prop) {
2143                 IDPropertyTemplate val = {0};
2144                 sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocketInterface ID properties");
2145         }
2146         
2147         return sock->prop;
2148 }
2149
2150 static void rna_NodeSocketInterface_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2151 {
2152         bNodeTree *ntree = ptr->id.data;
2153         bNodeSocket *stemp = ptr->data;
2154         
2155         if (!stemp->typeinfo)
2156                 return;
2157         
2158         ntree->update |= NTREE_UPDATE_GROUP;
2159         ntreeUpdateTree(G.main, ntree);
2160         
2161         ED_node_tag_update_nodetree(bmain, ntree);
2162 }
2163
2164
2165 /* ******** Standard Node Socket Base Types ******** */
2166
2167 static void rna_NodeSocketStandard_draw(ID *id, bNodeSocket *sock, struct bContext *C, struct uiLayout *layout, PointerRNA *nodeptr,
2168                                         const char *text)
2169 {
2170         PointerRNA ptr;
2171         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2172         sock->typeinfo->draw(C, layout, &ptr, nodeptr, text);
2173 }
2174
2175 static void rna_NodeSocketStandard_draw_color(ID *id, bNodeSocket *sock, struct bContext *C, PointerRNA *nodeptr, float *r_color)
2176 {
2177         PointerRNA ptr;
2178         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2179         sock->typeinfo->draw_color(C, &ptr, nodeptr, r_color);
2180 }
2181
2182 static void rna_NodeSocketInterfaceStandard_draw(ID *id, bNodeSocket *sock, struct bContext *C, struct uiLayout *layout)
2183 {
2184         PointerRNA ptr;
2185         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2186         sock->typeinfo->interface_draw(C, layout, &ptr);
2187 }
2188
2189 static void rna_NodeSocketInterfaceStandard_draw_color(ID *id, bNodeSocket *sock, struct bContext *C, float *r_color)
2190 {
2191         PointerRNA ptr;
2192         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2193         sock->typeinfo->interface_draw_color(C, &ptr, r_color);
2194 }
2195
2196 static void rna_NodeSocketStandard_float_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
2197 {
2198         bNodeSocket *sock = ptr->data;
2199         bNodeSocketValueFloat *dval = sock->default_value;
2200         int subtype = sock->typeinfo->subtype;
2201         
2202         if (dval->max < dval->min) {
2203                 dval->max = dval->min;
2204         }
2205         
2206         *min = (subtype == PROP_UNSIGNED ? 0.0f : -FLT_MAX);
2207         *max = FLT_MAX;
2208         *softmin = dval->min;
2209         *softmax = dval->max;
2210 }
2211
2212 static void rna_NodeSocketStandard_int_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
2213 {
2214         bNodeSocket *sock = ptr->data;
2215         bNodeSocketValueInt *dval = sock->default_value;
2216         int subtype = sock->typeinfo->subtype;
2217         
2218         if (dval->max < dval->min) {
2219                 dval->max = dval->min;
2220         }
2221         
2222         *min = (subtype == PROP_UNSIGNED ? 0 : INT_MIN);
2223         *max = INT_MAX;
2224         *softmin = dval->min;
2225         *softmax = dval->max;
2226 }
2227
2228 static void rna_NodeSocketStandard_vector_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
2229 {
2230         bNodeSocket *sock = ptr->data;
2231         bNodeSocketValueVector *dval = sock->default_value;
2232         
2233         if (dval->max < dval->min) {
2234                 dval->max = dval->min;
2235         }
2236         
2237         *min = -FLT_MAX;
2238         *max = FLT_MAX;
2239         *softmin = dval->min;
2240         *softmax = dval->max;
2241 }
2242
2243 /* using a context update function here, to avoid searching the node if possible */
2244 static void rna_NodeSocketStandard_value_update(struct bContext *C, PointerRNA *ptr)
2245 {
2246         bNode *node;
2247         
2248         /* default update */
2249         rna_NodeSocket_update(CTX_data_main(C), CTX_data_scene(C), ptr);
2250         
2251         /* try to use node from context, faster */
2252         node = CTX_data_pointer_get(C, "node").data;
2253         if (!node) {
2254                 bNodeTree *ntree = ptr->id.data;
2255                 bNodeSocket *sock = ptr->data;
2256                 
2257                 /* fall back to searching node in the tree */
2258                 nodeFindNode(ntree, sock, &node, NULL);
2259         }
2260         
2261         if (node) {
2262                 nodeSynchronizeID(node, true);
2263
2264                 /* extra update for sockets that get synced to material */
2265                 if (node->id && ELEM(node->type, SH_NODE_MATERIAL, SH_NODE_MATERIAL_EXT))
2266                         WM_main_add_notifier(NC_MATERIAL | ND_SHADING_DRAW, node->id);
2267         }
2268 }
2269
2270
2271 /* ******** Node Types ******** */
2272
2273 static void rna_NodeInternalSocketTemplate_name_get(PointerRNA *ptr, char *value)
2274 {
2275         bNodeSocketTemplate *stemp = ptr->data;
2276         strcpy(value, stemp->name);
2277 }
2278
2279 static int rna_NodeInternalSocketTemplate_name_length(PointerRNA *ptr)
2280 {
2281         bNodeSocketTemplate *stemp = ptr->data;
2282         return strlen(stemp->name);
2283 }
2284
2285 static void rna_NodeInternalSocketTemplate_identifier_get(PointerRNA *ptr, char *value)
2286 {
2287         bNodeSocketTemplate *stemp = ptr->data;
2288         strcpy(value, stemp->identifier);
2289 }
2290
2291 static int rna_NodeInternalSocketTemplate_identifier_length(PointerRNA *ptr)
2292 {
2293         bNodeSocketTemplate *stemp = ptr->data;
2294         return strlen(stemp->identifier);
2295 }
2296
2297 static int rna_NodeInternalSocketTemplate_type_get(PointerRNA *ptr)
2298 {
2299         bNodeSocketTemplate *stemp = ptr->data;
2300         return stemp->type;
2301 }
2302
2303 static PointerRNA rna_NodeInternal_input_template(StructRNA *srna, int index)
2304 {
2305         bNodeType *ntype = RNA_struct_blender_type_get(srna);
2306         if (ntype && ntype->inputs) {
2307                 bNodeSocketTemplate *stemp = ntype->inputs;
2308                 int i = 0;
2309                 while (i < index && stemp->type >= 0) {
2310                         ++i;
2311                         ++stemp;
2312                 }
2313                 if (i == index && stemp->type >= 0) {
2314                         PointerRNA ptr;
2315                         RNA_pointer_create(NULL, &RNA_NodeInternalSocketTemplate, stemp, &ptr);
2316                         return ptr;
2317                 }
2318         }
2319         return PointerRNA_NULL;
2320 }
2321
2322 static PointerRNA rna_NodeInternal_output_template(StructRNA *srna, int index)
2323 {
2324         bNodeType *ntype = RNA_struct_blender_type_get(srna);
2325         if (ntype && ntype->outputs) {
2326                 bNodeSocketTemplate *stemp = ntype->outputs;
2327                 int i = 0;
2328                 while (i < index && stemp->type >= 0) {
2329                         ++i;
2330                         ++stemp;
2331                 }
2332                 if (i == index && stemp->type >= 0) {
2333                         PointerRNA ptr;
2334                         RNA_pointer_create(NULL, &RNA_NodeInternalSocketTemplate, stemp, &ptr);
2335                         return ptr;
2336                 }
2337         }
2338         return PointerRNA_NULL;
2339 }
2340
2341 static int rna_NodeInternal_poll(StructRNA *srna, bNodeTree *ntree)
2342 {
2343         bNodeType *ntype = RNA_struct_blender_type_get(srna);
2344         return ntype && (!ntype->poll || ntype->poll(ntype, ntree));
2345 }
2346
2347 static int rna_NodeInternal_poll_instance(bNode *node, bNodeTree *ntree)
2348 {
2349         bNodeType *ntype = node->typeinfo;
2350         if (ntype->poll_instance) {
2351                 return ntype->poll_instance(node, ntree);
2352         }
2353         else {
2354                 /* fall back to basic poll function */
2355                 return !ntype->poll || ntype->poll(ntype, ntree);
2356         }
2357 }
2358
2359 static void rna_NodeInternal_update(ID *id, bNode *node)
2360 {
2361         bNodeTree *ntree = (bNodeTree *)id;
2362         if (node->typeinfo->updatefunc)
2363                 node->typeinfo->updatefunc(ntree, node);
2364 }
2365
2366 static void rna_NodeInternal_draw_buttons(ID *id, bNode *node, struct bContext *C, struct uiLayout *layout)
2367 {
2368         if (node->typeinfo->draw_buttons) {
2369                 PointerRNA ptr;
2370                 RNA_pointer_create(id, &RNA_Node, node, &ptr);
2371                 node->typeinfo->draw_buttons(layout, C, &ptr);
2372         }
2373 }
2374
2375 static void rna_NodeInternal_draw_buttons_ext(ID *id, bNode *node, struct bContext *C, struct uiLayout *layout)
2376 {
2377         if (node->typeinfo->draw_buttons_ex) {
2378                 PointerRNA ptr;
2379                 RNA_pointer_create(id, &RNA_Node, node, &ptr);
2380                 node->typeinfo->draw_buttons_ex(layout, C, &ptr);
2381         }
2382         else if (node->typeinfo->draw_buttons) {
2383                 PointerRNA ptr;
2384                 RNA_pointer_create(id, &RNA_Node, node, &ptr);
2385                 node->typeinfo->draw_buttons(layout, C, &ptr);
2386         }
2387 }
2388
2389 static StructRNA *rna_NodeCustomGroup_register(
2390         Main *bmain, ReportList *reports,
2391         void *data, const char *identifier,
2392         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
2393 {
2394         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_NodeCustomGroup, data, identifier, validate, call, free);
2395         if (!nt)
2396                 return NULL;
2397         
2398         /* this updates the group node instance from the tree's interface */
2399         nt->verifyfunc = node_group_verify;
2400         
2401         nodeRegisterType(nt);
2402         
2403         /* update while blender is running */
2404         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2405         
2406         return nt->ext.srna;
2407 }
2408
2409 static void rna_CompositorNode_tag_need_exec(bNode *node)
2410 {
2411         node->need_exec = true;
2412 }
2413
2414 static void rna_Node_tex_image_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2415 {
2416         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2417
2418         ED_node_tag_update_nodetree(bmain, ntree);
2419         WM_main_add_notifier(NC_IMAGE, NULL);
2420 }
2421
2422 static void rna_Node_material_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2423 {
2424         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2425         bNode *node = (bNode *)ptr->data;
2426
2427         if (node->id)
2428                 nodeSetActive(ntree, node);
2429
2430         ED_node_tag_update_nodetree(bmain, ntree);
2431 }
2432
2433 static void rna_NodeGroup_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2434 {
2435         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2436         bNode *node = (bNode *)ptr->data;
2437         
2438         if (node->id)
2439                 ntreeUpdateTree(bmain, (bNodeTree *)node->id);
2440         
2441         ED_node_tag_update_nodetree(bmain, ntree);
2442 }
2443
2444 static void rna_NodeGroup_node_tree_set(PointerRNA *ptr, const PointerRNA value)
2445 {
2446         bNodeTree *ntree = ptr->id.data;
2447         bNode *node = ptr->data;
2448         bNodeTree *ngroup = value.data;
2449         
2450         if (nodeGroupPoll(ntree, ngroup)) {
2451                 if (node->id)
2452                         id_us_min(node->id);
2453                 if (ngroup)
2454                         id_us_plus(&ngroup->id);
2455                 
2456                 node->id = &ngroup->id;
2457         }
2458 }
2459
2460 static int rna_NodeGroup_node_tree_poll(PointerRNA *ptr, const PointerRNA value)
2461 {
2462         bNodeTree *ntree = ptr->id.data;
2463         bNodeTree *ngroup = value.data;
2464         
2465         /* only allow node trees of the same type as the group node's tree */
2466         if (ngroup->type != ntree->type)
2467                 return false;
2468         
2469         return nodeGroupPoll(ntree, ngroup);
2470 }
2471
2472
2473 static StructRNA *rna_NodeGroup_interface_typef(PointerRNA *ptr)
2474 {
2475         bNode *node = ptr->data;
2476         bNodeTree *ngroup = (bNodeTree *)node->id;
2477
2478         if (ngroup) {
2479                 StructRNA *srna = ntreeInterfaceTypeGet(ngroup, true);
2480                 if (srna)
2481                         return srna;
2482         }
2483         return &RNA_PropertyGroup;
2484 }
2485
2486 static StructRNA *rna_NodeGroupInputOutput_interface_typef(PointerRNA *ptr)
2487 {
2488         bNodeTree *ntree = ptr->id.data;
2489         
2490         if (ntree) {
2491                 StructRNA *srna = ntreeInterfaceTypeGet(ntree, true);
2492                 if (srna)
2493                         return srna;
2494         }
2495         return &RNA_PropertyGroup;
2496 }
2497
2498 static void rna_distance_matte_t1_set(PointerRNA *ptr, float value)
2499 {
2500         bNode *node = (bNode *)ptr->data;
2501         NodeChroma *chroma = node->storage;
2502
2503         chroma->t1 = value;
2504 }
2505
2506 static void rna_distance_matte_t2_set(PointerRNA *ptr, float value)
2507 {
2508         bNode *node = (bNode *)ptr->data;
2509         NodeChroma *chroma = node->storage;
2510
2511         chroma->t2 = value;
2512 }
2513
2514 static void rna_difference_matte_t1_set(PointerRNA *ptr, float value)
2515 {
2516         bNode *node = (bNode *)ptr->data;
2517         NodeChroma *chroma = node->storage;
2518
2519         chroma->t1 = value;
2520 }
2521
2522 static void rna_difference_matte_t2_set(PointerRNA *ptr, float value)
2523 {
2524         bNode *node = (bNode *)ptr->data;
2525         NodeChroma *chroma = node->storage;
2526
2527         chroma->t2 = value;
2528 }
2529
2530 /* Button Set Funcs for Matte Nodes */
2531 static void rna_Matte_t1_set(PointerRNA *ptr, float value)
2532 {
2533         bNode *node = (bNode *)ptr->data;
2534         NodeChroma *chroma = node->storage;
2535         
2536         chroma->t1 = value;
2537         
2538         if (value < chroma->t2) 
2539                 chroma->t2 = value;
2540 }
2541
2542 static void rna_Matte_t2_set(PointerRNA *ptr, float value)
2543 {
2544         bNode *node = (bNode *)ptr->data;
2545         NodeChroma *chroma = node->storage;
2546         
2547         if (value > chroma->t1) 
2548                 value = chroma->t1;
2549         
2550         chroma->t2 = value;
2551 }
2552
2553 static void rna_Node_scene_set(PointerRNA *ptr, PointerRNA value)
2554 {
2555         bNode *node = (bNode *)ptr->data;
2556
2557         if (node->id) {
2558                 id_us_min(node->id);
2559                 node->id = NULL;
2560         }
2561
2562         node->id = value.data;
2563
2564         id_us_plus(node->id);
2565 }
2566
2567 static void rna_Node_image_layer_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2568 {
2569         bNode *node = (bNode *)ptr->data;
2570         Image *ima = (Image *)node->id;
2571         ImageUser *iuser = node->storage;
2572         
2573         BKE_image_multilayer_index(ima->rr, iuser);
2574         BKE_image_signal(ima, iuser, IMA_SIGNAL_SRC_CHANGE);
2575         
2576         rna_Node_update(bmain, scene, ptr);
2577 }
2578
2579 static EnumPropertyItem *renderresult_layers_add_enum(RenderLayer *rl)
2580 {
2581         EnumPropertyItem *item = NULL;
2582         EnumPropertyItem tmp = {0, "", 0, "", ""};
2583         int i = 0, totitem = 0;
2584         
2585         while (rl) {
2586                 tmp.identifier = rl->name;
2587                 /* little trick: using space char instead empty string makes the item selectable in the dropdown */
2588                 if (rl->name[0] == '\0')
2589                         tmp.name = " ";
2590                 else
2591                         tmp.name = rl->name;
2592                 tmp.value = i++;
2593                 RNA_enum_item_add(&item, &totitem, &tmp);
2594                 rl = rl->next;
2595         }
2596         
2597         RNA_enum_item_end(&item, &totitem);
2598
2599         return item;
2600 }
2601
2602 static EnumPropertyItem *rna_Node_image_layer_itemf(bContext *UNUSED(C), PointerRNA *ptr,
2603                                                     PropertyRNA *UNUSED(prop), bool *r_free)
2604 {
2605         bNode *node = (bNode *)ptr->data;
2606         Image *ima = (Image *)node->id;
2607         EnumPropertyItem *item = NULL;
2608         RenderLayer *rl;
2609         
2610         if (ima && ima->rr) {
2611                 rl = ima->rr->layers.first;
2612                 item = renderresult_layers_add_enum(rl);
2613         }
2614         else {
2615                 int totitem = 0;
2616                 RNA_enum_item_end(&item, &totitem);
2617         }
2618         
2619         *r_free = true;
2620         
2621         return item;
2622 }
2623
2624 static int rna_Node_image_has_layers_get(PointerRNA *ptr)
2625 {
2626         bNode *node = (bNode *)ptr->data;
2627         Image *ima = (Image *)node->id;
2628
2629         if (!ima || !(ima->rr)) return 0;
2630
2631         return RE_layers_have_name(ima->rr);
2632 }
2633
2634 static int rna_Node_image_has_views_get(PointerRNA *ptr)
2635 {
2636         bNode *node = (bNode *)ptr->data;
2637         Image *ima = (Image *)node->id;
2638
2639         if (!ima || !(ima->rr)) return 0;
2640
2641         return BLI_listbase_count_ex(&ima->rr->views, 2) > 1;
2642 }
2643
2644 static EnumPropertyItem *renderresult_views_add_enum(RenderView *rv)
2645 {
2646         EnumPropertyItem *item = NULL;
2647         EnumPropertyItem tmp = {0, "ALL", 0, "All", ""};
2648         int i = 1, totitem = 0;
2649
2650         /* option to use all views */
2651         RNA_enum_item_add(&item, &totitem, &tmp);
2652
2653         while (rv) {
2654                 tmp.identifier = rv->name;
2655                 /* little trick: using space char instead empty string makes the item selectable in the dropdown */
2656                 if (rv->name[0] == '\0')
2657                         tmp.name = " ";
2658                 else
2659                         tmp.name = rv->name;
2660                 tmp.value = i++;
2661                 RNA_enum_item_add(&item, &totitem, &tmp);
2662                 rv = rv->next;
2663         }
2664
2665         RNA_enum_item_end(&item, &totitem);
2666
2667         return item;
2668 }
2669
2670 static EnumPropertyItem *rna_Node_image_view_itemf(bContext *UNUSED(C), PointerRNA *ptr,
2671                                                    PropertyRNA *UNUSED(prop), bool *free)
2672 {
2673         bNode *node = (bNode *)ptr->data;
2674         Image *ima = (Image *)node->id;
2675         EnumPropertyItem *item = NULL;
2676         RenderView *rv;
2677
2678         if (!ima || !(ima->rr)) return NULL;
2679
2680         rv = ima->rr->views.first;
2681         item = renderresult_views_add_enum(rv);
2682
2683         *free = true;
2684
2685         return item;
2686 }
2687
2688 static EnumPropertyItem *rna_Node_scene_layer_itemf(bContext *UNUSED(C), PointerRNA *ptr,
2689                                                     PropertyRNA *UNUSED(prop), bool *r_free)
2690 {
2691         bNode *node = (bNode *)ptr->data;
2692         Scene *sce = (Scene *)node->id;
2693         EnumPropertyItem *item = NULL;
2694         RenderLayer *rl;
2695         
2696         if (sce) {
2697                 rl = sce->r.layers.first;
2698                 item = renderresult_layers_add_enum(rl);
2699         }
2700         else {
2701                 int totitem = 0;
2702                 RNA_enum_item_end(&item, &totitem);
2703         }
2704         
2705         *r_free = true;
2706         
2707         return item;
2708 }
2709
2710 static EnumPropertyItem *rna_Node_channel_itemf(bContext *UNUSED(C), PointerRNA *ptr,
2711                                                 PropertyRNA *UNUSED(prop), bool *r_free)
2712 {
2713         bNode *node = (bNode *)ptr->data;
2714         EnumPropertyItem *item = NULL;
2715         EnumPropertyItem tmp = {0, "", 0, "", ""};
2716         int totitem = 0;
2717         
2718         switch (node->custom1) {
2719                 case CMP_NODE_CHANNEL_MATTE_CS_RGB:
2720                         tmp.identifier = "R"; tmp.name = "R"; tmp.value = 1;
2721                         RNA_enum_item_add(&item, &totitem, &tmp);
2722                         tmp.identifier = "G"; tmp.name = "G"; tmp.value = 2;
2723                         RNA_enum_item_add(&item, &totitem, &tmp);
2724                         tmp.identifier = "B"; tmp.name = "B"; tmp.value = 3;
2725                         RNA_enum_item_add(&item, &totitem, &tmp);
2726                         break;
2727                 case CMP_NODE_CHANNEL_MATTE_CS_HSV:
2728                         tmp.identifier = "H"; tmp.name = "H"; tmp.value = 1;
2729                         RNA_enum_item_add(&item, &totitem, &tmp);
2730                         tmp.identifier = "S"; tmp.name = "S"; tmp.value = 2;
2731                         RNA_enum_item_add(&item, &totitem, &tmp);
2732                         tmp.identifier = "V"; tmp.name = "V"; tmp.value = 3;
2733                         RNA_enum_item_add(&item, &totitem, &tmp);
2734                         break;
2735                 case CMP_NODE_CHANNEL_MATTE_CS_YUV:
2736                         tmp.identifier = "Y"; tmp.name = "Y"; tmp.value = 1;
2737                         RNA_enum_item_add(&item, &totitem, &tmp);
2738                         tmp.identifier = "G"; tmp.name = "U"; tmp.value = 2;
2739                         RNA_enum_item_add(&item, &totitem, &tmp);
2740                         tmp.identifier = "V"; tmp.name = "V"; tmp.value = 3;
2741                         RNA_enum_item_add(&item, &totitem, &tmp);
2742                         break;
2743                 case CMP_NODE_CHANNEL_MATTE_CS_YCC:
2744                         tmp.identifier = "Y"; tmp.name = "Y"; tmp.value = 1;
2745                         RNA_enum_item_add(&item, &totitem, &tmp);
2746                         tmp.identifier = "CB"; tmp.name = "Cr"; tmp.value = 2;
2747                         RNA_enum_item_add(&item, &totitem, &tmp);
2748                         tmp.identifier = "CR"; tmp.name = "Cb"; tmp.value = 3;
2749                         RNA_enum_item_add(&item, &totitem, &tmp);
2750                         break;
2751                 default:
2752                         break;
2753         }
2754
2755         RNA_enum_item_end(&item, &totitem);
2756         *r_free = true;
2757         
2758         return item;
2759 }
2760
2761 static void rna_Image_Node_update_id(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
2762 {
2763         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2764         bNode *node = (bNode *)ptr->data;
2765
2766         node->update |= NODE_UPDATE_ID;
2767         nodeUpdate(ntree, node);        /* to update image node sockets */
2768 }
2769
2770 static void rna_Mapping_Node_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2771 {
2772         bNode *node = ptr->data;
2773         BKE_texture_mapping_init(node->storage);
2774         rna_Node_update(bmain, scene, ptr);
2775 }
2776
2777 static void rna_NodeOutputFile_slots_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
2778 {
2779         bNode *node = ptr->data;
2780         rna_iterator_listbase_begin(iter, &node->inputs, NULL);
2781 }
2782
2783 static PointerRNA rna_NodeOutputFile_slot_file_get(CollectionPropertyIterator *iter)
2784 {
2785         PointerRNA ptr;
2786         bNodeSocket *sock = rna_iterator_listbase_get(iter);
2787         RNA_pointer_create(iter->parent.id.data, &RNA_NodeOutputFileSlotFile, sock->storage, &ptr);
2788         return ptr;
2789 }
2790
2791 static void rna_NodeColorBalance_update_lgg(Main *bmain, Scene *scene, PointerRNA *ptr)
2792 {
2793         ntreeCompositColorBalanceSyncFromLGG(ptr->id.data, ptr->data);
2794         rna_Node_update(bmain, scene, ptr);
2795 }
2796
2797 static void rna_NodeColorBalance_update_cdl(Main *bmain, Scene *scene, PointerRNA *ptr)
2798 {
2799         ntreeCompositColorBalanceSyncFromCDL(ptr->id.data, ptr->data);
2800         rna_Node_update(bmain, scene, ptr);
2801 }
2802
2803 /* ******** Node Socket Types ******** */
2804
2805 static PointerRNA rna_NodeOutputFile_slot_layer_get(CollectionPropertyIterator *iter)
2806 {
2807         PointerRNA ptr;
2808         bNodeSocket *sock = rna_iterator_listbase_get(iter);
2809         RNA_pointer_create(iter->parent.id.data, &RNA_NodeOutputFileSlotLayer, sock->storage, &ptr);
2810         return ptr;
2811 }
2812
2813 static int rna_NodeOutputFileSocket_find_node(bNodeTree *ntree, NodeImageMultiFileSocket *data, bNode **nodep, bNodeSocket **sockp)
2814 {
2815         bNode *node;
2816         bNodeSocket *sock;
2817         
2818         for (node = ntree->nodes.first; node; node = node->next) {
2819                 for (sock = node->inputs.first; sock; sock = sock->next) {
2820                         NodeImageMultiFileSocket *sockdata = sock->storage;
2821                         if (sockdata == data) {
2822                                 *nodep = node;
2823                                 *sockp = sock;
2824                                 return 1;
2825                         }
2826                 }
2827         }
2828         
2829         *nodep = NULL;
2830         *sockp = NULL;
2831         return 0;
2832 }
2833
2834 static void rna_NodeOutputFileSlotFile_path_set(PointerRNA *ptr, const char *value)
2835 {
2836         bNodeTree *ntree = ptr->id.data;
2837         NodeImageMultiFileSocket *sockdata = ptr->data;
2838         bNode *node;
2839         bNodeSocket *sock;
2840         
2841         if (rna_NodeOutputFileSocket_find_node(ntree, sockdata, &node, &sock)) {
2842                 ntreeCompositOutputFileSetPath(node, sock, value);
2843         }
2844 }
2845
2846 static void rna_NodeOutputFileSlotLayer_name_set(PointerRNA *ptr, const char *value)
2847 {
2848         bNodeTree *ntree = ptr->id.data;
2849         NodeImageMultiFileSocket *sockdata = ptr->data;
2850         bNode *node;
2851         bNodeSocket *sock;
2852         
2853         if (rna_NodeOutputFileSocket_find_node(ntree, sockdata, &node, &sock)) {
2854                 ntreeCompositOutputFileSetLayer(node, sock, value);
2855         }
2856 }
2857
2858 static bNodeSocket *rna_NodeOutputFile_slots_new(ID *id, bNode *node, bContext *C, ReportList *UNUSED(reports), const char *name)
2859 {
2860         bNodeTree *ntree = (bNodeTree *)id;
2861         Scene *scene = CTX_data_scene(C);
2862         ImageFormatData *im_format = NULL;
2863         bNodeSocket *sock;
2864         if (scene)
2865                 im_format = &scene->r.im_format;
2866         
2867         sock = ntreeCompositOutputFileAddSocket(ntree, node, name, im_format);
2868         
2869         ntreeUpdateTree(CTX_data_main(C), ntree);
2870         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2871         
2872         return sock;
2873 }
2874
2875 static void rna_ShaderNodeScript_mode_set(PointerRNA *ptr, int value)
2876 {
2877         bNode *node = (bNode *)ptr->data;
2878         NodeShaderScript *nss = node->storage;
2879
2880         if (nss->mode != value) {
2881                 nss->mode = value;
2882                 nss->filepath[0] = '\0';
2883                 nss->flag &= ~NODE_SCRIPT_AUTO_UPDATE;
2884
2885                 /* replace text datablock by filepath */
2886                 if (node->id) {
2887                         Text *text = (Text *)node->id;
2888
2889                         if (value == NODE_SCRIPT_EXTERNAL && text->name) {
2890                                 BLI_strncpy(nss->filepath, text->name, sizeof(nss->filepath));
2891                                 BLI_path_rel(nss->filepath, G.main->name);
2892                         }
2893
2894                         id_us_min(node->id);
2895                         node->id = NULL;
2896                 }
2897
2898                 /* remove any bytecode */
2899                 if (nss->bytecode) {
2900                         MEM_freeN(nss->bytecode);
2901                         nss->bytecode = NULL;
2902                 }
2903
2904                 nss->bytecode_hash[0] = '\0';
2905         }
2906 }
2907
2908 static void rna_ShaderNodeScript_bytecode_get(PointerRNA *ptr, char *value)
2909 {
2910         bNode *node = (bNode *)ptr->data;
2911         NodeShaderScript *nss = node->storage;
2912
2913         strcpy(value, (nss->bytecode) ? nss->bytecode : "");
2914 }
2915
2916 static int rna_ShaderNodeScript_bytecode_length(PointerRNA *ptr)
2917 {
2918         bNode *node = (bNode *)ptr->data;
2919         NodeShaderScript *nss = node->storage;
2920
2921         return (nss->bytecode) ? strlen(nss->bytecode) : 0;
2922 }
2923
2924 static void rna_ShaderNodeScript_bytecode_set(PointerRNA *ptr, const char *value)
2925 {
2926         bNode *node = (bNode *)ptr->data;
2927         NodeShaderScript *nss = node->storage;
2928
2929         if (nss->bytecode)
2930                 MEM_freeN(nss->bytecode);
2931
2932         if (value && value[0])
2933                 nss->bytecode = BLI_strdup(value);
2934         else
2935                 nss->bytecode = NULL;
2936 }
2937
2938 static void rna_ShaderNodeScript_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2939 {
2940         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2941         bNode *node = (bNode *)ptr->data;
2942         RenderEngineType *engine_type = RE_engines_find(scene->r.engine);
2943
2944         if (engine_type && engine_type->update_script_node) {
2945                 /* auto update node */
2946                 RenderEngine *engine = RE_engine_create(engine_type);
2947                 engine_type->update_script_node(engine, ntree, node);
2948                 RE_engine_free(engine);
2949         }
2950
2951         ED_node_tag_update_nodetree(bmain, ntree);
2952 }
2953
2954 static void rna_ShaderNodeSubsurface_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2955 {
2956         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2957         bNode *node = (bNode *)ptr->data;
2958
2959         nodeUpdate(ntree, node);
2960         rna_Node_update(bmain, scene, ptr);
2961 }
2962
2963 static void rna_CompositorNodeScale_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2964 {
2965         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2966         bNode *node = (bNode *)ptr->data;
2967
2968         nodeUpdate(ntree, node);
2969         rna_Node_update(bmain, scene, ptr);
2970 }
2971
2972 #else
2973
2974 static EnumPropertyItem prop_image_layer_items[] = {
2975         { 0, "PLACEHOLDER",          0, "Placeholder",          ""},
2976         {0, NULL, 0, NULL, NULL}
2977 };
2978
2979 static EnumPropertyItem prop_image_view_items[] = {
2980         { 0, "ALL", 0, "All", ""},
2981         {0, NULL, 0, NULL, NULL}
2982 };
2983
2984 static EnumPropertyItem prop_scene_layer_items[] = {
2985         { 0, "PLACEHOLDER",          0, "Placeholder",          ""},
2986         {0, NULL, 0, NULL, NULL}
2987 };
2988
2989 static EnumPropertyItem prop_tri_channel_items[] = {
2990         { 1, "R", 0, "R", ""},
2991         { 2, "G", 0, "G", ""},
2992         { 3, "B", 0, "B", ""},
2993         {0, NULL, 0, NULL, NULL}
2994 };
2995
2996 static EnumPropertyItem node_flip_items[] = {
2997         {0, "X",  0, "Flip X",     ""},
2998         {1, "Y",  0, "Flip Y",     ""},
2999         {2, "XY", 0, "Flip X & Y", ""},
3000         {0, NULL, 0, NULL, NULL}
3001 };
3002
3003 static EnumPropertyItem node_ycc_items[] = {
3004         { 0, "ITUBT601", 0, "ITU 601",  ""},
3005         { 1, "ITUBT709", 0, "ITU 709",  ""},
3006         { 2, "JFIF",     0, "Jpeg",     ""},
3007         {0, NULL, 0, NULL, NULL}
3008 };
3009
3010 static EnumPropertyItem node_glossy_items[] = {
3011         {SHD_GLOSSY_SHARP,             "SHARP",             0, "Sharp",    ""},
3012         {SHD_GLOSSY_BECKMANN,          "BECKMANN",          0, "Beckmann", ""},
3013         {SHD_GLOSSY_GGX,               "GGX",               0, "GGX",      ""},
3014         {SHD_GLOSSY_ASHIKHMIN_SHIRLEY, "ASHIKHMIN_SHIRLEY", 0, "Ashikhmin-Shirley", ""},
3015         {0, NULL, 0, NULL, NULL}
3016 };
3017
3018 static EnumPropertyItem node_anisotropic_items[] = {
3019         {SHD_GLOSSY_BECKMANN,          "BECKMANN",          0, "Beckmann", ""},
3020         {SHD_GLOSSY_GGX,               "GGX",               0, "GGX",      ""},
3021         {SHD_GLOSSY_ASHIKHMIN_SHIRLEY, "ASHIKHMIN_SHIRLEY", 0, "Ashikhmin-Shirley", ""},
3022         {0, NULL, 0, NULL, NULL}
3023 };
3024
3025 static EnumPropertyItem node_glass_items[] = {
3026         {SHD_GLOSSY_SHARP,             "SHARP",             0, "Sharp",    ""},
3027         {SHD_GLOSSY_BECKMANN,          "BECKMANN",          0, "Beckmann", ""},
3028         {SHD_GLOSSY_GGX,               "GGX",               0, "GGX",      ""},
3029         {0, NULL, 0, NULL, NULL}
3030 };
3031
3032 static EnumPropertyItem node_toon_items[] = {
3033         {SHD_TOON_DIFFUSE,    "DIFFUSE",  0, "Diffuse", ""},
3034         {SHD_TOON_GLOSSY,     "GLOSSY",   0, "Glossy",  ""},
3035         {0, NULL, 0, NULL, NULL}
3036 };
3037
3038 static EnumPropertyItem node_hair_items[] = {
3039         {SHD_HAIR_REFLECTION,     "Reflection",    0,   "Reflection", ""},
3040         {SHD_HAIR_TRANSMISSION,   "Transmission",    0,  "Transmission", ""},
3041         {0, NULL, 0, NULL, NULL}
3042 };
3043
3044 static EnumPropertyItem node_script_mode_items[] = {
3045         {NODE_SCRIPT_INTERNAL, "INTERNAL", 0, "Internal", "Use internal text datablock"},
3046         {NODE_SCRIPT_EXTERNAL, "EXTERNAL", 0, "External", "Use external .osl or .oso file"},
3047         {0, NULL, 0, NULL, NULL}
3048 };
3049
3050 /* -- Common nodes ---------------------------------------------------------- */
3051
3052 static void def_group_input(StructRNA *srna)
3053 {
3054         PropertyRNA *prop;
3055         
3056         prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
3057         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroupInputOutput_interface_typef", NULL);
3058         RNA_def_property_struct_type(prop, "PropertyGroup");
3059         RNA_def_property_flag(prop, PROP_IDPROPERTY);
3060         RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
3061 }
3062
3063 static void def_group_output(StructRNA *srna)
3064 {
3065         PropertyRNA *prop;
3066         
3067         prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
3068         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroupInputOutput_interface_typef", NULL);
3069         RNA_def_property_struct_type(prop, "PropertyGroup");
3070         RNA_def_property_flag(prop, PROP_IDPROPERTY);
3071         RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
3072         
3073         prop = RNA_def_property(srna, "is_active_output", PROP_BOOLEAN, PROP_NONE);
3074         RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_DO_OUTPUT);
3075         RNA_def_property_ui_text(prop, "Active Output", "True if this node is used as the active group output");
3076         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3077 }
3078
3079 static void def_group(StructRNA *srna)
3080 {
3081         PropertyRNA *prop;
3082         
3083         prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
3084         RNA_def_property_pointer_sdna(prop, NULL, "id");
3085         RNA_def_property_struct_type(prop, "NodeTree");
3086         RNA_def_property_pointer_funcs(prop, NULL, "rna_NodeGroup_node_tree_set", NULL, "rna_NodeGroup_node_tree_poll");
3087         RNA_def_property_flag(prop, PROP_EDITABLE);
3088         RNA_def_property_ui_text(prop, "Node Tree", "");
3089         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeGroup_update");
3090
3091         prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
3092         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroup_interface_typef", NULL);
3093         RNA_def_property_struct_type(prop, "PropertyGroup");
3094         RNA_def_property_flag(prop, PROP_IDPROPERTY);
3095         RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
3096 }
3097
3098 static void def_custom_group(BlenderRNA *brna)
3099 {
3100         StructRNA *srna;
3101         
3102         srna = RNA_def_struct(brna, "NodeCustomGroup", "Node");
3103         RNA_def_struct_ui_text(srna, "Custom Group", "Base node type for custom registered node group types");
3104         RNA_def_struct_sdna(srna, "bNode");
3105
3106         RNA_def_struct_register_funcs(srna, "rna_NodeCustomGroup_register", "rna_Node_unregister", NULL);
3107
3108         def_group(srna);
3109 }
3110
3111 static void def_frame(StructRNA *srna)
3112 {
3113         PropertyRNA *prop; 
3114         
3115         prop = RNA_def_property(srna, "text", PROP_POINTER, PROP_NONE);
3116         RNA_def_property_pointer_sdna(prop, NULL, "id");
3117         RNA_def_property_struct_type(prop, "Text");
3118         RNA_def_property_flag(prop, PROP_EDITABLE);
3119         RNA_def_property_ui_text(prop, "Text", "");
3120         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3121
3122         RNA_def_struct_sdna_from(srna, "NodeFrame", "storage");
3123         
3124         prop = RNA_def_property(srna, "shrink", PROP_BOOLEAN, PROP_NONE);
3125         RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_FRAME_SHRINK);
3126         RNA_def_property_ui_text(prop, "Shrink", "Shrink the frame to minimal bounding box");
3127         RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL);
3128
3129         prop = RNA_def_property(srna, "label_size", PROP_INT, PROP_NONE);
3130         RNA_def_property_int_sdna(prop, NULL, "label_size");
3131         RNA_def_property_range(prop, 8, 64);
3132         RNA_def_property_ui_text(prop, "Label Font Size", "Font size to use for displaying the label");
3133         RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL);
3134 }
3135
3136 static void def_math(StructRNA *srna)
3137 {
3138         PropertyRNA *prop;
3139         
3140         prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
3141         RNA_def_property_enum_sdna(prop, NULL, "custom1");
3142         RNA_def_property_enum_items(prop, node_math_items);
3143         RNA_def_property_ui_text(prop, "Operation", "");
3144         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3145
3146         prop = RNA_def_property(srna, "use_clamp", PROP_BOOLEAN, PROP_NONE);
3147         RNA_def_property_boolean_sdna(prop, NULL, "custom2", SHD_MATH_CLAMP);
3148         RNA_def_property_ui_text(prop, "Clamp", "Clamp result of the node to 0..1 range");
3149         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3150 }
3151
3152 static void def_vector_math(StructRNA *srna)
3153 {
3154         PropertyRNA *prop;
3155         
3156         prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
3157         RNA_def_property_enum_sdna(prop, NULL, "custom1");
3158         RNA_def_property_enum_items(prop, node_vec_math_items);
3159         RNA_def_property_ui_text(prop, "Operation", "");
3160         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3161 }
3162
3163 static void def_rgb_curve(StructRNA *srna)
3164 {
3165         PropertyRNA *prop;
3166         
3167         prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
3168         RNA_def_property_pointer_sdna(prop, NULL, "storage");
3169         RNA_def_property_struct_type(prop, "CurveMapping");
3170         RNA_def_property_ui_text(prop, "Mapping", "");
3171         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3172 }
3173
3174 static void def_vector_curve(StructRNA *srna)
3175 {
3176         PropertyRNA *prop;
3177         
3178         prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
3179         RNA_def_property_pointer_sdna(prop, NULL, "storage");
3180         RNA_def_property_struct_type(prop, "CurveMapping");
3181         RNA_def_property_ui_text(prop, "Mapping", "");
3182         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3183 }
3184
3185 static void def_time(StructRNA *srna)
3186 {
3187         PropertyRNA *prop;
3188         
3189         prop = RNA_def_property(srna, "curve", PROP_POINTER, PROP_NONE);
3190         RNA_def_property_pointer_sdna(prop, NULL, "storage");
3191         RNA_def_property_struct_type(prop, "CurveMapping");
3192         RNA_def_property_ui_text(prop, "Curve", "");
3193         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3194         
3195         prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_NONE);
3196         RNA_def_property_int_sdna(prop, NULL, "custom1");
3197         RNA_def_property_ui_text(prop, "Start Frame", "");
3198         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3199         
3200         prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_NONE);
3201         RNA_def_property_int_sdna(prop, NULL, "custom2");
3202         RNA_def_property_ui_text(prop, "End Frame", "");
3203         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3204 }
3205
3206 static void def_colorramp(StructRNA *srna)
3207 {
3208         PropertyRNA *prop;
3209         
3210         prop = RNA_def_property(srna, "color_ramp", PROP_POINTER, PROP_NONE);
3211         RNA_def_property_pointer_sdna(prop, NULL, "storage");
3212         RNA_def_property_struct_type(prop, "ColorRamp");
3213         RNA_def_property_ui_text(prop, "Color Ramp", "");
3214         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3215 }
3216
3217 static void def_mix_rgb(StructRNA *srna)
3218 {
3219         PropertyRNA *prop;
3220         
3221         prop = RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
3222         RNA_def_property_enum_sdna(prop, NULL, "custom1");
3223         RNA_def_property_enum_items(prop, ramp_blend_items);
3224         RNA_def_property_ui_text(prop, "Blend Type", "");
3225         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3226         
3227         prop = RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
3228         RNA_def_property_boolean_sdna(prop, NULL, "custom2", SHD_MIXRGB_USE_ALPHA);
3229         RNA_def_property_ui_text(prop, "Alpha", "Include alpha of second input in this operation");
3230         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3231
3232         prop = RNA_def_property(srna, "use_clamp", PROP_BOOLEAN, PROP_NONE);
3233         RNA_def_property_boolean_sdna(prop, NULL, "custom2", SHD_MIXRGB_CLAMP);
3234         RNA_def_property_ui_text(prop, "Clamp", "Clamp result of the node to 0..1 range");
3235         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3236 }
3237
3238 static void def_texture(StructRNA *srna)
3239 {
3240         PropertyRNA *prop;
3241         
3242         prop = RNA_def_property(srna, "texture", PROP_POINTER, PROP_NONE);
3243         RNA_def_property_pointer_sdna(prop, NULL, "id");
3244         RNA_def_property_struct_type(prop, "Texture");
3245         RNA_def_property_flag(prop, PROP_EDITABLE);
3246         RNA_def_property_ui_text(prop, "Texture", "");
3247         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3248         
3249         prop = RNA_def_property(srna, "node_output", PROP_INT, PROP_NONE);
3250         RNA_def_property_int_sdna(prop, NULL, "custom1");
3251         RNA_def_property_ui_text(prop, "Node Output", "For node-based textures, which output node to use");
3252         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3253 }
3254
3255
3256 /* -- Shader Nodes ---------------------------------------------------------- */
3257
3258 static void def_sh_output(StructRNA *srna)
3259 {
3260         PropertyRNA *prop;
3261         
3262         prop = RNA_def_property(srna, "is_active_output", PROP_BOOLEAN, PROP_NONE);
3263         RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_DO_OUTPUT);
3264         RNA_def_property_ui_text(prop, "Active Output", "True if this node is used as the active output");
3265         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3266 }
3267
3268 static void def_sh_output_linestyle(StructRNA *srna)
3269 {
3270         def_sh_output(srna);
3271         def_mix_rgb(srna);
3272 }
3273
3274 static void def_sh_material(StructRNA *srna)
3275 {
3276         PropertyRNA *prop;
3277
3278         prop = RNA_def_property(srna, "material", PROP_POINTER, PROP_NONE);
3279         RNA_def_property_pointer_sdna(prop, NULL, "id");
3280         RNA_def_property_struct_type(prop, "Material");
3281         RNA_def_property_flag(prop, PROP_EDITABLE);
3282         RNA_def_property_ui_text(prop, "Material", "");
3283         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_material_update");
3284
3285         prop = RNA_def_property(srna, "use_diffuse", PROP_BOOLEAN, PROP_NONE);
3286         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_DIFF);
3287         RNA_def_property_ui_text(prop, "Diffuse", "Material Node outputs Diffuse");
3288         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3289
3290         prop = RNA_def_property(srna, "use_specular", PROP_BOOLEAN, PROP_NONE);
3291         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_SPEC);
3292         RNA_def_property_ui_text(prop, "Specular", "Material Node outputs Specular");
3293         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3294         
3295         prop = RNA_def_property(srna, "invert_normal", PROP_BOOLEAN, PROP_NONE);
3296         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_NEG);
3297         RNA_def_property_ui_text(prop, "Invert Normal", "Material Node uses inverted normal");
3298         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3299 }
3300
3301 static void def_sh_mapping(StructRNA *srna)
3302 {
3303         static EnumPropertyItem prop_vect_type_items[] = {
3304                 {TEXMAP_TYPE_TEXTURE, "TEXTURE", 0, "Texture", "Transform a texture by inverse mapping the texture coordinate"},
3305                 {TEXMAP_TYPE_POINT,   "POINT",   0, "Point",   "Transform a point"},
3306                 {TEXMAP_TYPE_VECTOR,  "VECTOR",  0, "Vector",  "Transform a direction vector"},
3307                 {TEXMAP_TYPE_NORMAL,  "NORMAL",  0, "Normal",  "Transform a normal vector with unit length"},
3308                 {0, NULL, 0, NULL, NULL}
3309         };
3310
3311         static float default_1[3] = {1.f, 1.f, 1.f};
3312
3313         PropertyRNA *prop;
3314         
3315         RNA_def_struct_sdna_from(srna, "TexMapping", "storage");
3316
3317         prop = RNA_def_property(srna, "vector_type", PROP_ENUM, PROP_NONE);
3318         RNA_def_property_enum_sdna(prop, NULL, "type");
3319         RNA_def_property_enum_items(prop, prop_vect_type_items);
3320         RNA_def_property_ui_text(prop, "Type", "Type of vector that the mapping transforms");
3321         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3322
3323         prop = RNA_def_property(srna, "translation", PROP_FLOAT, PROP_TRANSLATION);
3324         RNA_def_property_float_sdna(prop, NULL, "loc");
3325         RNA_def_property_ui_text(prop, "Location", "");
3326         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3327         
3328         /* Not PROP_XYZ, this is now in radians, no more degrees */
3329         prop = RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_EULER);
3330         RNA_def_property_float_sdna(prop, NULL, "rot");
3331         RNA_def_property_ui_text(prop, "Rotation", "");
3332         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3333         
3334         prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
3335         RNA_def_property_float_sdna(prop, NULL, "size");
3336         RNA_def_property_float_array_default(prop, default_1);
3337         RNA_def_property_flag(prop, PROP_PROPORTIONAL);
3338         RNA_def_property_ui_text(prop, "Scale", "");
3339         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3340         
3341         prop = RNA_def_property(srna, "min", PROP_FLOAT, PROP_XYZ);
3342