2d412bf778b8ca155cfa49abaf9936c02c327c73
[blender.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_utildefines.h"
34
35 #include "BLT_translation.h"
36
37 #include "DNA_material_types.h"
38 #include "DNA_mesh_types.h"
39 #include "DNA_node_types.h"
40 #include "DNA_object_types.h"
41 #include "DNA_particle_types.h"
42 #include "DNA_text_types.h"
43 #include "DNA_texture_types.h"
44
45 #include "BKE_animsys.h"
46 #include "BKE_main.h"
47 #include "BKE_node.h"
48 #include "BKE_image.h"
49 #include "BKE_texture.h"
50
51 #include "RNA_access.h"
52 #include "RNA_define.h"
53 #include "RNA_enum_types.h"
54
55 #include "rna_internal.h"
56 #include "rna_internal_types.h"
57
58 #include "IMB_imbuf.h"
59 #include "IMB_imbuf_types.h"
60
61 #include "WM_types.h"
62
63 #include "MEM_guardedalloc.h"
64
65 #include "RE_render_ext.h"
66
67 EnumPropertyItem rna_enum_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 rna_enum_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 rna_enum_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 rna_enum_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 rna_enum_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
796                 /* not an issue from the UI, clear hidden from API to keep valid state. */
797                 fromsock->flag &= ~SOCK_HIDDEN;
798                 tosock->flag   &= ~SOCK_HIDDEN;
799
800                 if (tonode)
801                         nodeUpdate(ntree, tonode);
802
803                 ntreeUpdateTree(G.main, ntree);
804
805                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
806         }
807         return ret;
808 }
809
810 static void rna_NodeTree_link_remove(bNodeTree *ntree, ReportList *reports, PointerRNA *link_ptr)
811 {
812         bNodeLink *link = link_ptr->data;
813
814         if (!rna_NodeTree_check(ntree, reports))
815                 return;
816
817         if (BLI_findindex(&ntree->links, link) == -1) {
818                 BKE_report(reports, RPT_ERROR, "Unable to locate link in node tree");
819                 return;
820         }
821
822         nodeRemLink(ntree, link);
823         RNA_POINTER_INVALIDATE(link_ptr);
824
825         ntreeUpdateTree(G.main, ntree);
826         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
827 }
828
829 static void rna_NodeTree_link_clear(bNodeTree *ntree, ReportList *reports)
830 {
831         bNodeLink *link = ntree->links.first;
832
833         if (!rna_NodeTree_check(ntree, reports))
834                 return;
835
836         while (link) {
837                 bNodeLink *next_link = link->next;
838
839                 nodeRemLink(ntree, link);
840
841                 link = next_link;
842         }
843         ntreeUpdateTree(G.main, ntree);
844
845         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
846 }
847
848 static int rna_NodeTree_active_input_get(PointerRNA *ptr)
849 {
850         bNodeTree *ntree = (bNodeTree *)ptr->data;
851         bNodeSocket *gsock;
852         int index;
853
854         for (gsock = ntree->inputs.first, index = 0; gsock; gsock = gsock->next, ++index)
855                 if (gsock->flag & SELECT)
856                         return index;
857         return -1;
858 }
859
860 static void rna_NodeTree_active_input_set(PointerRNA *ptr, int value)
861 {
862         bNodeTree *ntree = (bNodeTree *)ptr->data;
863         bNodeSocket *gsock;
864         int index;
865         
866         for (gsock = ntree->inputs.first, index = 0; gsock; gsock = gsock->next, ++index) {
867                 if (index == value)
868                         gsock->flag |= SELECT;
869                 else
870                         gsock->flag &= ~SELECT;
871         }
872         for (gsock = ntree->outputs.first; gsock; gsock = gsock->next) {
873                 gsock->flag &= ~SELECT;
874         }
875 }
876
877 static int rna_NodeTree_active_output_get(PointerRNA *ptr)
878 {
879         bNodeTree *ntree = (bNodeTree *)ptr->data;
880         bNodeSocket *gsock;
881         int index;
882
883         for (gsock = ntree->outputs.first, index = 0; gsock; gsock = gsock->next, ++index)
884                 if (gsock->flag & SELECT)
885                         return index;
886         return -1;
887 }
888
889 static void rna_NodeTree_active_output_set(PointerRNA *ptr, int value)
890 {
891         bNodeTree *ntree = (bNodeTree *)ptr->data;
892         bNodeSocket *gsock;
893         int index;
894         
895         for (gsock = ntree->inputs.first; gsock; gsock = gsock->next) {
896                 gsock->flag &= ~SELECT;
897         }
898         for (gsock = ntree->outputs.first, index = 0; gsock; gsock = gsock->next, ++index) {
899                 if (index == value)
900                         gsock->flag |= SELECT;
901                 else
902                         gsock->flag &= ~SELECT;
903         }
904 }
905
906 static bNodeSocket *rna_NodeTree_inputs_new(bNodeTree *ntree, ReportList *reports, const char *type, const char *name)
907 {
908         bNodeSocket *sock;
909         
910         if (!rna_NodeTree_check(ntree, reports))
911                 return NULL;
912         
913         sock = ntreeAddSocketInterface(ntree, SOCK_IN, type, name);
914         
915         ntreeUpdateTree(G.main, ntree);
916         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
917         
918         return sock;
919 }
920
921 static bNodeSocket *rna_NodeTree_outputs_new(bNodeTree *ntree, ReportList *reports, const char *type, const char *name)
922 {
923         bNodeSocket *sock;
924         
925         if (!rna_NodeTree_check(ntree, reports))
926                 return NULL;
927         
928         sock = ntreeAddSocketInterface(ntree, SOCK_OUT, type, name);
929         
930         ntreeUpdateTree(G.main, ntree);
931         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
932         
933         return sock;
934 }
935
936 static void rna_NodeTree_socket_remove(bNodeTree *ntree, ReportList *reports, bNodeSocket *sock)
937 {
938         if (!rna_NodeTree_check(ntree, reports))
939                 return;
940         
941         if (BLI_findindex(&ntree->inputs, sock) == -1 && BLI_findindex(&ntree->outputs, sock) == -1) {
942                 BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier);
943         }
944         else {
945                 ntreeRemoveSocketInterface(ntree, sock);
946                 
947                 ntreeUpdateTree(G.main, ntree);
948                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
949         }
950 }
951
952 static void rna_NodeTree_inputs_clear(bNodeTree *ntree, ReportList *reports)
953 {
954         bNodeSocket *sock, *nextsock;
955         
956         if (!rna_NodeTree_check(ntree, reports))
957                 return;
958         
959         for (sock = ntree->inputs.first; sock; sock = nextsock) {
960                 nextsock = sock->next;
961                 ntreeRemoveSocketInterface(ntree, sock);
962         }
963
964         ntreeUpdateTree(G.main, ntree);
965         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
966 }
967
968 static void rna_NodeTree_outputs_clear(bNodeTree *ntree, ReportList *reports)
969 {
970         bNodeSocket *sock, *nextsock;
971         
972         if (!rna_NodeTree_check(ntree, reports))
973                 return;
974         
975         for (sock = ntree->outputs.first; sock; sock = nextsock) {
976                 nextsock = sock->next;
977                 ntreeRemoveSocketInterface(ntree, sock);
978         }
979
980         ntreeUpdateTree(G.main, ntree);
981         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
982 }
983
984 static void rna_NodeTree_inputs_move(bNodeTree *ntree, int from_index, int to_index)
985 {
986         bNodeSocket *sock;
987         
988         if (from_index == to_index)
989                 return;
990         if (from_index < 0 || to_index < 0)
991                 return;
992         
993         sock = BLI_findlink(&ntree->inputs, from_index);
994         if (to_index < from_index) {
995                 bNodeSocket *nextsock = BLI_findlink(&ntree->inputs, to_index);
996                 if (nextsock) {
997                         BLI_remlink(&ntree->inputs, sock);
998                         BLI_insertlinkbefore(&ntree->inputs, nextsock, sock);
999                 }
1000         }
1001         else {
1002                 bNodeSocket *prevsock = BLI_findlink(&ntree->inputs, to_index);
1003                 if (prevsock) {
1004                         BLI_remlink(&ntree->inputs, sock);
1005                         BLI_insertlinkafter(&ntree->inputs, prevsock, sock);
1006                 }
1007         }
1008         
1009         ntree->update |= NTREE_UPDATE_GROUP_IN;
1010         
1011         ntreeUpdateTree(G.main, ntree);
1012         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1013 }
1014
1015 static void rna_NodeTree_outputs_move(bNodeTree *ntree, int from_index, int to_index)
1016 {
1017         bNodeSocket *sock;
1018         
1019         if (from_index == to_index)
1020                 return;
1021         if (from_index < 0 || to_index < 0)
1022                 return;
1023         
1024         sock = BLI_findlink(&ntree->outputs, from_index);
1025         if (to_index < from_index) {
1026                 bNodeSocket *nextsock = BLI_findlink(&ntree->outputs, to_index);
1027                 if (nextsock) {
1028                         BLI_remlink(&ntree->outputs, sock);
1029                         BLI_insertlinkbefore(&ntree->outputs, nextsock, sock);
1030                 }
1031         }
1032         else {
1033                 bNodeSocket *prevsock = BLI_findlink(&ntree->outputs, to_index);
1034                 if (prevsock) {
1035                         BLI_remlink(&ntree->outputs, sock);
1036                         BLI_insertlinkafter(&ntree->outputs, prevsock, sock);
1037                 }
1038         }
1039         
1040         ntree->update |= NTREE_UPDATE_GROUP_OUT;
1041         
1042         ntreeUpdateTree(G.main, ntree);
1043         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1044 }
1045
1046 static void rna_NodeTree_interface_update(bNodeTree *ntree, bContext *C)
1047 {
1048         ntree->update |= NTREE_UPDATE_GROUP;
1049         ntreeUpdateTree(G.main, ntree);
1050         
1051         ED_node_tag_update_nodetree(CTX_data_main(C), ntree);
1052 }
1053
1054
1055 /* ******** NodeLink ******** */
1056
1057 static int rna_NodeLink_is_hidden_get(PointerRNA *ptr)
1058 {
1059         bNodeLink *link = ptr->data;
1060         return nodeLinkIsHidden(link);
1061 }
1062
1063
1064 /* ******** Node ******** */
1065
1066 static StructRNA *rna_Node_refine(struct PointerRNA *ptr)
1067 {
1068         bNode *node = (bNode *)ptr->data;
1069         
1070         if (node->typeinfo->ext.srna)
1071                 return node->typeinfo->ext.srna;
1072         else
1073                 return ptr->type;
1074 }
1075
1076 static char *rna_Node_path(PointerRNA *ptr)
1077 {
1078         bNode *node = (bNode *)ptr->data;
1079         char name_esc[sizeof(node->name) * 2];
1080
1081         BLI_strescape(name_esc, node->name, sizeof(name_esc));
1082         return BLI_sprintfN("nodes[\"%s\"]", name_esc);
1083 }
1084
1085 char *rna_Node_ImageUser_path(PointerRNA *ptr)
1086 {
1087         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1088         bNode *node;
1089         char name_esc[sizeof(node->name) * 2];
1090
1091         for (node = ntree->nodes.first; node; node = node->next) {
1092                 if (node->type == SH_NODE_TEX_ENVIRONMENT) {
1093                         NodeTexEnvironment *data = node->storage;
1094                         if (&data->iuser != ptr->data)
1095                                 continue;
1096                 }
1097                 else if (node->type == SH_NODE_TEX_IMAGE) {
1098                         NodeTexImage *data = node->storage;
1099                         if (&data->iuser != ptr->data)
1100                                 continue;
1101                 }
1102                 else
1103                         continue;
1104
1105                 BLI_strescape(name_esc, node->name, sizeof(name_esc));
1106                 return BLI_sprintfN("nodes[\"%s\"].image_user", name_esc);
1107         }
1108
1109         return NULL;
1110 }
1111
1112 static int rna_Node_poll(bNodeType *ntype, bNodeTree *ntree)
1113 {
1114         extern FunctionRNA rna_Node_poll_func;
1115
1116         PointerRNA ptr;
1117         ParameterList list;
1118         FunctionRNA *func;
1119         void *ret;
1120         int visible;
1121
1122         RNA_pointer_create(NULL, ntype->ext.srna, NULL, &ptr); /* dummy */
1123         func = &rna_Node_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */
1124
1125         RNA_parameter_list_create(&list, &ptr, func);
1126         RNA_parameter_set_lookup(&list, "node_tree", &ntree);
1127         ntype->ext.call(NULL, &ptr, func, &list);
1128
1129         RNA_parameter_get_lookup(&list, "visible", &ret);
1130         visible = *(int *)ret;
1131
1132         RNA_parameter_list_free(&list);
1133
1134         return visible;
1135 }
1136
1137 static int rna_Node_poll_instance(bNode *node, bNodeTree *ntree)
1138 {
1139         extern FunctionRNA rna_Node_poll_instance_func;
1140
1141         PointerRNA ptr;
1142         ParameterList list;
1143         FunctionRNA *func;
1144         void *ret;
1145         int visible;
1146
1147         RNA_pointer_create(NULL, node->typeinfo->ext.srna, node, &ptr); /* dummy */
1148         func = &rna_Node_poll_instance_func; /* RNA_struct_find_function(&ptr, "poll_instance"); */
1149
1150         RNA_parameter_list_create(&list, &ptr, func);
1151         RNA_parameter_set_lookup(&list, "node_tree", &ntree);
1152         node->typeinfo->ext.call(NULL, &ptr, func, &list);
1153
1154         RNA_parameter_get_lookup(&list, "visible", &ret);
1155         visible = *(int *)ret;
1156
1157         RNA_parameter_list_free(&list);
1158
1159         return visible;
1160 }
1161
1162 static int rna_Node_poll_instance_default(bNode *node, bNodeTree *ntree)
1163 {
1164         /* use the basic poll function */
1165         return rna_Node_poll(node->typeinfo, ntree);
1166 }
1167
1168 static void rna_Node_update_reg(bNodeTree *ntree, bNode *node)
1169 {
1170         extern FunctionRNA rna_Node_update_func;
1171
1172         PointerRNA ptr;
1173         ParameterList list;
1174         FunctionRNA *func;
1175
1176         RNA_pointer_create((ID *)ntree, node->typeinfo->ext.srna, node, &ptr);
1177         func = &rna_Node_update_func; /* RNA_struct_find_function(&ptr, "update"); */
1178
1179         RNA_parameter_list_create(&list, &ptr, func);
1180         node->typeinfo->ext.call(NULL, &ptr, func, &list);
1181
1182         RNA_parameter_list_free(&list);
1183 }
1184
1185 static void rna_Node_init(const bContext *C, PointerRNA *ptr)
1186 {
1187         extern FunctionRNA rna_Node_init_func;
1188
1189         bNode *node = (bNode *)ptr->data;
1190         ParameterList list;
1191         FunctionRNA *func;
1192
1193         func = &rna_Node_init_func; /* RNA_struct_find_function(&ptr, "init"); */
1194
1195         RNA_parameter_list_create(&list, ptr, func);
1196         node->typeinfo->ext.call((bContext *)C, ptr, func, &list);
1197
1198         RNA_parameter_list_free(&list);
1199 }
1200
1201 static void rna_Node_copy(PointerRNA *ptr, struct bNode *copynode)
1202 {
1203         extern FunctionRNA rna_Node_copy_func;
1204
1205         bNode *node = (bNode *)ptr->data;
1206         ParameterList list;
1207         FunctionRNA *func;
1208
1209         func = &rna_Node_copy_func; /* RNA_struct_find_function(&ptr, "copy"); */
1210
1211         RNA_parameter_list_create(&list, ptr, func);
1212         RNA_parameter_set_lookup(&list, "node", &copynode);
1213         node->typeinfo->ext.call(NULL, ptr, func, &list);
1214
1215         RNA_parameter_list_free(&list);
1216 }
1217
1218 static void rna_Node_free(PointerRNA *ptr)
1219 {
1220         extern FunctionRNA rna_Node_free_func;
1221
1222         bNode *node = (bNode *)ptr->data;
1223         ParameterList list;
1224         FunctionRNA *func;
1225
1226         func = &rna_Node_free_func; /* RNA_struct_find_function(&ptr, "free"); */
1227
1228         RNA_parameter_list_create(&list, ptr, func);
1229         node->typeinfo->ext.call(NULL, ptr, func, &list);
1230
1231         RNA_parameter_list_free(&list);
1232 }
1233
1234 static void rna_Node_draw_buttons(struct uiLayout *layout, bContext *C, PointerRNA *ptr)
1235 {
1236         extern FunctionRNA rna_Node_draw_buttons_func;
1237
1238         bNode *node = (bNode *)ptr->data;
1239         ParameterList list;
1240         FunctionRNA *func;
1241
1242         func = &rna_Node_draw_buttons_func; /* RNA_struct_find_function(&ptr, "draw_buttons"); */
1243
1244         RNA_parameter_list_create(&list, ptr, func);
1245         RNA_parameter_set_lookup(&list, "context", &C);
1246         RNA_parameter_set_lookup(&list, "layout", &layout);
1247         node->typeinfo->ext.call(C, ptr, func, &list);
1248
1249         RNA_parameter_list_free(&list);
1250 }
1251
1252 static void rna_Node_draw_buttons_ext(struct uiLayout *layout, bContext *C, PointerRNA *ptr)
1253 {
1254         extern FunctionRNA rna_Node_draw_buttons_ext_func;
1255
1256         bNode *node = (bNode *)ptr->data;
1257         ParameterList list;
1258         FunctionRNA *func;
1259
1260         func = &rna_Node_draw_buttons_ext_func; /* RNA_struct_find_function(&ptr, "draw_buttons_ext"); */
1261
1262         RNA_parameter_list_create(&list, ptr, func);
1263         RNA_parameter_set_lookup(&list, "context", &C);
1264         RNA_parameter_set_lookup(&list, "layout", &layout);
1265         node->typeinfo->ext.call(C, ptr, func, &list);
1266
1267         RNA_parameter_list_free(&list);
1268 }
1269
1270 static void rna_Node_draw_label(bNodeTree *ntree, bNode *node, char *label, int maxlen)
1271 {
1272         extern FunctionRNA rna_Node_draw_label_func;
1273
1274         PointerRNA ptr;
1275         ParameterList list;
1276         FunctionRNA *func;
1277         void *ret;
1278         char *rlabel;
1279
1280         func = &rna_Node_draw_label_func; /* RNA_struct_find_function(&ptr, "draw_label"); */
1281
1282         RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr);
1283         RNA_parameter_list_create(&list, &ptr, func);
1284         node->typeinfo->ext.call(NULL, &ptr, func, &list);
1285
1286         RNA_parameter_get_lookup(&list, "label", &ret);
1287         rlabel = *(char **)ret;
1288         BLI_strncpy(label, rlabel != NULL ? rlabel : "", maxlen);
1289
1290         RNA_parameter_list_free(&list);
1291 }
1292
1293 static int rna_Node_is_registered_node_type(StructRNA *type)
1294 {
1295         return (RNA_struct_blender_type_get(type) != NULL);
1296 }
1297
1298 static void rna_Node_is_registered_node_type_runtime(bContext *UNUSED(C), ReportList *UNUSED(reports), PointerRNA *ptr, ParameterList *parms)
1299 {
1300         int result = (RNA_struct_blender_type_get(ptr->type) != NULL);
1301         RNA_parameter_set_lookup(parms, "result", &result);
1302 }
1303
1304 static void rna_Node_unregister(Main *UNUSED(bmain), StructRNA *type)
1305 {
1306         bNodeType *nt = RNA_struct_blender_type_get(type);
1307
1308         if (!nt)
1309                 return;
1310
1311         RNA_struct_free_extension(type, &nt->ext);
1312
1313         /* this also frees the allocated nt pointer, no MEM_free call needed! */
1314         nodeUnregisterType(nt);
1315
1316         RNA_struct_free(&BLENDER_RNA, type);
1317
1318         /* update while blender is running */
1319         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1320 }
1321
1322 /* Generic internal registration function.
1323  * Can be used to implement callbacks for registerable RNA node subtypes.
1324  */
1325 static bNodeType *rna_Node_register_base(Main *bmain, ReportList *reports, StructRNA *basetype,
1326                                          void *data, const char *identifier,
1327                                          StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1328 {
1329         bNodeType *nt, dummynt;
1330         bNode dummynode;
1331         PointerRNA dummyptr;
1332         FunctionRNA *func;
1333         PropertyRNA *parm;
1334         int have_function[9];
1335
1336         /* setup dummy node & node type to store static properties in */
1337         memset(&dummynt, 0, sizeof(bNodeType));
1338         /* this does some additional initialization of default values */
1339         node_type_base_custom(&dummynt, identifier, "", 0, 0);
1340
1341         memset(&dummynode, 0, sizeof(bNode));
1342         dummynode.typeinfo = &dummynt;
1343         RNA_pointer_create(NULL, basetype, &dummynode, &dummyptr);
1344
1345         /* validate the python class */
1346         if (validate(&dummyptr, data, have_function) != 0)
1347                 return NULL;
1348
1349         if (strlen(identifier) >= sizeof(dummynt.idname)) {
1350                 BKE_reportf(reports, RPT_ERROR, "Registering node class: '%s' is too long, maximum length is %d",
1351                             identifier, (int)sizeof(dummynt.idname));
1352                 return NULL;
1353         }
1354
1355         /* check if we have registered this node type before, and remove it */
1356         nt = nodeTypeFind(dummynt.idname);
1357         if (nt)
1358                 rna_Node_unregister(bmain, nt->ext.srna);
1359         
1360         /* create a new node type */
1361         nt = MEM_callocN(sizeof(bNodeType), "node type");
1362         memcpy(nt, &dummynt, sizeof(dummynt));
1363         /* make sure the node type struct is freed on unregister */
1364         nt->needs_free = 1;
1365
1366         nt->ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, nt->idname, basetype);
1367         nt->ext.data = data;
1368         nt->ext.call = call;
1369         nt->ext.free = free;
1370         RNA_struct_blender_type_set(nt->ext.srna, nt);
1371
1372         RNA_def_struct_ui_text(nt->ext.srna, nt->ui_name, nt->ui_description);
1373         RNA_def_struct_ui_icon(nt->ext.srna, nt->ui_icon);
1374
1375         func = RNA_def_function_runtime(nt->ext.srna, "is_registered_node_type", rna_Node_is_registered_node_type_runtime);
1376         RNA_def_function_ui_description(func, "True if a registered node type");
1377         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_SELF_TYPE);
1378         parm = RNA_def_boolean(func, "result", false, "Result", "");
1379         RNA_def_function_return(func, parm);
1380
1381         /* XXX bad level call! needed to initialize the basic draw functions ... */
1382         ED_init_custom_node_type(nt);
1383
1384         nt->poll = (have_function[0]) ? rna_Node_poll : NULL;
1385         nt->poll_instance = (have_function[1]) ? rna_Node_poll_instance : rna_Node_poll_instance_default;
1386         nt->updatefunc = (have_function[2]) ? rna_Node_update_reg : NULL;
1387         nt->initfunc_api = (have_function[3]) ? rna_Node_init : NULL;
1388         nt->copyfunc_api = (have_function[4]) ? rna_Node_copy : NULL;
1389         nt->freefunc_api = (have_function[5]) ? rna_Node_free : NULL;
1390         nt->draw_buttons = (have_function[6]) ? rna_Node_draw_buttons : NULL;
1391         nt->draw_buttons_ex = (have_function[7]) ? rna_Node_draw_buttons_ext : NULL;
1392         nt->labelfunc = (have_function[8]) ? rna_Node_draw_label : NULL;
1393         
1394         /* sanitize size values in case not all have been registered */
1395         if (nt->maxwidth < nt->minwidth)
1396                 nt->maxwidth = nt->minwidth;
1397         if (nt->maxheight < nt->minheight)
1398                 nt->maxheight = nt->minheight;
1399         CLAMP(nt->width, nt->minwidth, nt->maxwidth);
1400         CLAMP(nt->height, nt->minheight, nt->maxheight);
1401         
1402         return nt;
1403 }
1404
1405 static StructRNA *rna_Node_register(
1406         Main *bmain, ReportList *reports,
1407         void *data, const char *identifier,
1408         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1409 {
1410         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_Node, data, identifier, validate, call, free);
1411         if (!nt)
1412                 return NULL;
1413         
1414         nodeRegisterType(nt);
1415         
1416         /* update while blender is running */
1417         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1418         
1419         return nt->ext.srna;
1420 }
1421
1422 static StructRNA *rna_ShaderNode_register(
1423         Main *bmain, ReportList *reports,
1424         void *data, const char *identifier,
1425         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1426 {
1427         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_ShaderNode, data, identifier, validate, call, free);
1428         if (!nt)
1429                 return NULL;
1430         
1431         nodeRegisterType(nt);
1432         
1433         /* update while blender is running */
1434         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1435         
1436         return nt->ext.srna;
1437 }
1438
1439 static StructRNA *rna_CompositorNode_register(
1440         Main *bmain, ReportList *reports,
1441         void *data, const char *identifier,
1442         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1443 {
1444         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_CompositorNode, data, identifier, validate, call, free);
1445         if (!nt)
1446                 return NULL;
1447         
1448         nodeRegisterType(nt);
1449         
1450         /* update while blender is running */
1451         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1452         
1453         return nt->ext.srna;
1454 }
1455
1456 static StructRNA *rna_TextureNode_register(
1457         Main *bmain, ReportList *reports,
1458         void *data, const char *identifier,
1459         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1460 {
1461         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_TextureNode, data, identifier, validate, call, free);
1462         if (!nt)
1463                 return NULL;
1464         
1465         nodeRegisterType(nt);
1466         
1467         /* update while blender is running */
1468         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1469         
1470         return nt->ext.srna;
1471 }
1472
1473 static IDProperty *rna_Node_idprops(PointerRNA *ptr, bool create)
1474 {
1475         bNode *node = ptr->data;
1476         
1477         if (create && !node->prop) {
1478                 IDPropertyTemplate val = {0};
1479                 node->prop = IDP_New(IDP_GROUP, &val, "RNA_Node ID properties");
1480         }
1481         
1482         return node->prop;
1483 }
1484
1485 static void rna_Node_parent_set(PointerRNA *ptr, PointerRNA value)
1486 {
1487         bNode *node = ptr->data;
1488         bNode *parent = value.data;
1489         
1490         if (parent) {
1491                 /* XXX only Frame node allowed for now,
1492                  * in the future should have a poll function or so to test possible attachment.
1493                  */
1494                 if (parent->type != NODE_FRAME)
1495                         return;
1496                 
1497                 /* make sure parent is not attached to the node */
1498                 if (nodeAttachNodeCheck(parent, node))
1499                         return;
1500         }
1501         
1502         nodeDetachNode(node);
1503         if (parent) {
1504                 nodeAttachNode(node, parent);
1505         }
1506 }
1507
1508 static int rna_Node_parent_poll(PointerRNA *ptr, PointerRNA value)
1509 {
1510         bNode *node = ptr->data;
1511         bNode *parent = value.data;
1512         
1513         /* XXX only Frame node allowed for now,
1514          * in the future should have a poll function or so to test possible attachment.
1515          */
1516         if (parent->type != NODE_FRAME)
1517                 return false;
1518         
1519         /* make sure parent is not attached to the node */
1520         if (nodeAttachNodeCheck(parent, node))
1521                 return false;
1522         
1523         return true;
1524 }
1525
1526 static void rna_Node_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
1527 {
1528         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1529         ED_node_tag_update_nodetree(bmain, ntree);
1530 }
1531
1532 static void rna_Node_socket_value_update(ID *id, bNode *UNUSED(node), bContext *C)
1533 {
1534         ED_node_tag_update_nodetree(CTX_data_main(C), (bNodeTree *)id);
1535 }
1536
1537 static void rna_Node_select_set(PointerRNA *ptr, int value)
1538 {
1539         bNode *node = (bNode *)ptr->data;
1540         nodeSetSelected(node, value);
1541 }
1542
1543 static void rna_Node_name_set(PointerRNA *ptr, const char *value)
1544 {
1545         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1546         bNode *node = (bNode *)ptr->data;
1547         char oldname[sizeof(node->name)];
1548         
1549         /* make a copy of the old name first */
1550         BLI_strncpy(oldname, node->name, sizeof(node->name));
1551         /* set new name */
1552         BLI_strncpy_utf8(node->name, value, sizeof(node->name));
1553         
1554         nodeUniqueName(ntree, node);
1555         
1556         /* fix all the animation data which may link to this */
1557         BKE_animdata_fix_paths_rename_all(NULL, "nodes", oldname, node->name);
1558 }
1559
1560 static bNodeSocket *rna_Node_inputs_new(ID *id, bNode *node, ReportList *reports, const char *type, const char *name, const char *identifier)
1561 {
1562         bNodeTree *ntree = (bNodeTree *)id;
1563         bNodeSocket *sock;
1564         
1565         sock = nodeAddSocket(ntree, node, SOCK_IN, type, identifier, name);
1566         
1567         if (sock == NULL) {
1568                 BKE_report(reports, RPT_ERROR, "Unable to create socket");
1569         }
1570         else {
1571                 ntreeUpdateTree(G.main, ntree);
1572                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1573         }
1574         
1575         return sock;
1576 }
1577
1578 static bNodeSocket *rna_Node_outputs_new(ID *id, bNode *node, ReportList *reports, const char *type, const char *name, const char *identifier)
1579 {
1580         bNodeTree *ntree = (bNodeTree *)id;
1581         bNodeSocket *sock;
1582         
1583         sock = nodeAddSocket(ntree, node, SOCK_OUT, type, identifier, name);
1584         
1585         if (sock == NULL) {
1586                 BKE_report(reports, RPT_ERROR, "Unable to create socket");
1587         }
1588         else {
1589                 ntreeUpdateTree(G.main, ntree);
1590                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1591         }
1592         
1593         return sock;
1594 }
1595
1596 static void rna_Node_socket_remove(ID *id, bNode *node, ReportList *reports, bNodeSocket *sock)
1597 {
1598         bNodeTree *ntree = (bNodeTree *)id;
1599         
1600         if (BLI_findindex(&node->inputs, sock) == -1 && BLI_findindex(&node->outputs, sock) == -1) {
1601                 BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier);
1602         }
1603         else {
1604                 nodeRemoveSocket(ntree, node, sock);
1605                 
1606                 ntreeUpdateTree(G.main, ntree);
1607                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1608         }
1609 }
1610
1611 static void rna_Node_inputs_clear(ID *id, bNode *node)
1612 {
1613         bNodeTree *ntree = (bNodeTree *)id;
1614         bNodeSocket *sock, *nextsock;
1615         
1616         for (sock = node->inputs.first; sock; sock = nextsock) {
1617                 nextsock = sock->next;
1618                 nodeRemoveSocket(ntree, node, sock);
1619         }
1620
1621         ntreeUpdateTree(G.main, ntree);
1622         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1623 }
1624
1625 static void rna_Node_outputs_clear(ID *id, bNode *node)
1626 {
1627         bNodeTree *ntree = (bNodeTree *)id;
1628         bNodeSocket *sock, *nextsock;
1629         
1630         for (sock = node->outputs.first; sock; sock = nextsock) {
1631                 nextsock = sock->next;
1632                 nodeRemoveSocket(ntree, node, sock);
1633         }
1634
1635         ntreeUpdateTree(G.main, ntree);
1636         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1637 }
1638
1639 static void rna_Node_inputs_move(ID *id, bNode *node, int from_index, int to_index)
1640 {
1641         bNodeTree *ntree = (bNodeTree *)id;
1642         bNodeSocket *sock;
1643         
1644         if (from_index == to_index)
1645                 return;
1646         if (from_index < 0 || to_index < 0)
1647                 return;
1648         
1649         sock = BLI_findlink(&node->inputs, from_index);
1650         if (to_index < from_index) {
1651                 bNodeSocket *nextsock = BLI_findlink(&node->inputs, to_index);
1652                 if (nextsock) {
1653                         BLI_remlink(&node->inputs, sock);
1654                         BLI_insertlinkbefore(&node->inputs, nextsock, sock);
1655                 }
1656         }
1657         else {
1658                 bNodeSocket *prevsock = BLI_findlink(&node->inputs, to_index);
1659                 if (prevsock) {
1660                         BLI_remlink(&node->inputs, sock);
1661                         BLI_insertlinkafter(&node->inputs, prevsock, sock);
1662                 }
1663         }
1664         
1665         ntreeUpdateTree(G.main, ntree);
1666         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1667 }
1668
1669 static void rna_Node_outputs_move(ID *id, bNode *node, int from_index, int to_index)
1670 {
1671         bNodeTree *ntree = (bNodeTree *)id;
1672         bNodeSocket *sock;
1673         
1674         if (from_index == to_index)
1675                 return;
1676         if (from_index < 0 || to_index < 0)
1677                 return;
1678         
1679         sock = BLI_findlink(&node->outputs, from_index);
1680         if (to_index < from_index) {
1681                 bNodeSocket *nextsock = BLI_findlink(&node->outputs, to_index);
1682                 if (nextsock) {
1683                         BLI_remlink(&node->outputs, sock);
1684                         BLI_insertlinkbefore(&node->outputs, nextsock, sock);
1685                 }
1686         }
1687         else {
1688                 bNodeSocket *prevsock = BLI_findlink(&node->outputs, to_index);
1689                 if (prevsock) {
1690                         BLI_remlink(&node->outputs, sock);
1691                         BLI_insertlinkafter(&node->outputs, prevsock, sock);
1692                 }
1693         }
1694         
1695         ntreeUpdateTree(G.main, ntree);
1696         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1697 }
1698
1699 static void rna_Node_width_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
1700 {
1701         bNode *node = ptr->data;
1702         *min = *softmin = node->typeinfo->minwidth;
1703         *max = *softmax = node->typeinfo->maxwidth;
1704 }
1705
1706 static void rna_Node_height_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
1707 {
1708         bNode *node = ptr->data;
1709         *min = *softmin = node->typeinfo->minheight;
1710         *max = *softmax = node->typeinfo->maxheight;
1711 }
1712
1713 static void rna_Node_dimensions_get(PointerRNA *ptr, float *value)
1714 {
1715         bNode *node = ptr->data;
1716         value[0] = node->totr.xmax - node->totr.xmin;
1717         value[1] = node->totr.ymax - node->totr.ymin;
1718 }
1719
1720
1721 /* ******** Node Socket ******** */
1722
1723 static void rna_NodeSocket_draw(bContext *C, struct uiLayout *layout, PointerRNA *ptr, PointerRNA *node_ptr, const char *text)
1724 {
1725         extern FunctionRNA rna_NodeSocket_draw_func;
1726
1727         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1728         ParameterList list;
1729         FunctionRNA *func;
1730
1731         func = &rna_NodeSocket_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
1732
1733         RNA_parameter_list_create(&list, ptr, func);
1734         RNA_parameter_set_lookup(&list, "context", &C);
1735         RNA_parameter_set_lookup(&list, "layout", &layout);
1736         RNA_parameter_set_lookup(&list, "node", node_ptr);
1737         RNA_parameter_set_lookup(&list, "text", &text);
1738         sock->typeinfo->ext_socket.call(C, ptr, func, &list);
1739
1740         RNA_parameter_list_free(&list);
1741 }
1742
1743 static void rna_NodeSocket_draw_color(bContext *C, PointerRNA *ptr, PointerRNA *node_ptr, float *r_color)
1744 {
1745         extern FunctionRNA rna_NodeSocket_draw_color_func;
1746
1747         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1748         ParameterList list;
1749         FunctionRNA *func;
1750         void *ret;
1751
1752         func = &rna_NodeSocket_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
1753
1754         RNA_parameter_list_create(&list, ptr, func);
1755         RNA_parameter_set_lookup(&list, "context", &C);
1756         RNA_parameter_set_lookup(&list, "node", node_ptr);
1757         sock->typeinfo->ext_socket.call(C, ptr, func, &list);
1758
1759         RNA_parameter_get_lookup(&list, "color", &ret);
1760         copy_v4_v4(r_color, (float *)ret);
1761
1762         RNA_parameter_list_free(&list);
1763 }
1764
1765 static void rna_NodeSocket_unregister(Main *UNUSED(bmain), StructRNA *type)
1766 {
1767         bNodeSocketType *st = RNA_struct_blender_type_get(type);
1768         if (!st)
1769                 return;
1770         
1771         RNA_struct_free_extension(type, &st->ext_socket);
1772
1773         nodeUnregisterSocketType(st);
1774
1775         RNA_struct_free(&BLENDER_RNA, type);
1776
1777         /* update while blender is running */
1778         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1779 }
1780
1781 static StructRNA *rna_NodeSocket_register(
1782         Main *UNUSED(bmain), ReportList *reports, void *data, const char *identifier,
1783         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1784 {
1785         bNodeSocketType *st, dummyst;
1786         bNodeSocket dummysock;
1787         PointerRNA dummyptr;
1788         int have_function[2];
1789
1790         /* setup dummy socket & socket type to store static properties in */
1791         memset(&dummyst, 0, sizeof(bNodeSocketType));
1792         
1793         memset(&dummysock, 0, sizeof(bNodeSocket));
1794         dummysock.typeinfo = &dummyst;
1795         RNA_pointer_create(NULL, &RNA_NodeSocket, &dummysock, &dummyptr);
1796
1797         /* validate the python class */
1798         if (validate(&dummyptr, data, have_function) != 0)
1799                 return NULL;
1800         
1801         if (strlen(identifier) >= sizeof(dummyst.idname)) {
1802                 BKE_reportf(reports, RPT_ERROR, "Registering node socket class: '%s' is too long, maximum length is %d",
1803                             identifier, (int)sizeof(dummyst.idname));
1804                 return NULL;
1805         }
1806
1807         /* check if we have registered this socket type before */
1808         st = nodeSocketTypeFind(dummyst.idname);
1809         if (!st) {
1810                 /* create a new node socket type */
1811                 st = MEM_callocN(sizeof(bNodeSocketType), "node socket type");
1812                 memcpy(st, &dummyst, sizeof(dummyst));
1813                 
1814                 nodeRegisterSocketType(st);
1815         }
1816         
1817         /* if RNA type is already registered, unregister first */
1818         if (st->ext_socket.srna) {
1819                 StructRNA *srna = st->ext_socket.srna;
1820                 RNA_struct_free_extension(srna, &st->ext_socket);
1821                 RNA_struct_free(&BLENDER_RNA, srna);
1822         }
1823         st->ext_socket.srna = RNA_def_struct_ptr(&BLENDER_RNA, st->idname, &RNA_NodeSocket); 
1824         st->ext_socket.data = data;
1825         st->ext_socket.call = call;
1826         st->ext_socket.free = free;
1827         RNA_struct_blender_type_set(st->ext_socket.srna, st);
1828         
1829         /* XXX bad level call! needed to initialize the basic draw functions ... */
1830         ED_init_custom_node_socket_type(st);
1831
1832         st->draw = (have_function[0]) ? rna_NodeSocket_draw : NULL;
1833         st->draw_color = (have_function[1]) ? rna_NodeSocket_draw_color : NULL;
1834
1835         /* update while blender is running */
1836         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1837         
1838         return st->ext_socket.srna;
1839 }
1840
1841 static StructRNA *rna_NodeSocket_refine(PointerRNA *ptr)
1842 {
1843         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1844         
1845         if (sock->typeinfo->ext_socket.srna)
1846                 return sock->typeinfo->ext_socket.srna;
1847         else
1848                 return &RNA_NodeSocket;
1849 }
1850
1851 static char *rna_NodeSocket_path(PointerRNA *ptr)
1852 {
1853         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1854         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1855         bNode *node;
1856         int socketindex;
1857         char name_esc[sizeof(node->name) * 2];
1858         
1859         if (!nodeFindNode(ntree, sock, &node, &socketindex))
1860                 return NULL;
1861         
1862         BLI_strescape(name_esc, node->name, sizeof(name_esc));
1863
1864         if (sock->in_out == SOCK_IN) {
1865                 return BLI_sprintfN("nodes[\"%s\"].inputs[%d]", name_esc, socketindex);
1866         }
1867         else {
1868                 return BLI_sprintfN("nodes[\"%s\"].outputs[%d]", name_esc, socketindex);
1869         }
1870 }
1871
1872 static IDProperty *rna_NodeSocket_idprops(PointerRNA *ptr, bool create)
1873 {
1874         bNodeSocket *sock = ptr->data;
1875         
1876         if (create && !sock->prop) {
1877                 IDPropertyTemplate val = {0};
1878                 sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocket ID properties");
1879         }
1880         
1881         return sock->prop;
1882 }
1883
1884 static PointerRNA rna_NodeSocket_node_get(PointerRNA *ptr)
1885 {
1886         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1887         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1888         bNode *node;
1889         PointerRNA r_ptr;
1890         
1891         nodeFindNode(ntree, sock, &node, NULL);
1892         
1893         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &r_ptr);
1894         return r_ptr;
1895 }
1896
1897 static void rna_NodeSocket_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
1898 {
1899         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1900         ED_node_tag_update_nodetree(bmain, ntree);
1901 }
1902
1903 static int rna_NodeSocket_is_output_get(PointerRNA *ptr)
1904 {
1905         bNodeSocket *sock = ptr->data;
1906         return sock->in_out == SOCK_OUT;
1907 }
1908
1909 static void rna_NodeSocket_link_limit_set(PointerRNA *ptr, int value)
1910 {
1911         bNodeSocket *sock = ptr->data;
1912         sock->limit = (value == 0 ? 0xFFF : value);
1913 }
1914
1915 static void rna_NodeSocket_hide_set(PointerRNA *ptr, int value)
1916 {
1917         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1918         
1919         /* don't hide linked sockets */
1920         if (sock->flag & SOCK_IN_USE)
1921                 return;
1922         
1923         if (value)
1924                 sock->flag |= SOCK_HIDDEN;
1925         else
1926                 sock->flag &= ~SOCK_HIDDEN;
1927 }
1928
1929
1930 static void rna_NodeSocketInterface_draw(bContext *C, struct uiLayout *layout, PointerRNA *ptr)
1931 {
1932         extern FunctionRNA rna_NodeSocketInterface_draw_func;
1933
1934         bNodeSocket *stemp = (bNodeSocket *)ptr->data;
1935         ParameterList list;
1936         FunctionRNA *func;
1937
1938         if (!stemp->typeinfo)
1939                 return;
1940
1941         func = &rna_NodeSocketInterface_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
1942
1943         RNA_parameter_list_create(&list, ptr, func);
1944         RNA_parameter_set_lookup(&list, "context", &C);
1945         RNA_parameter_set_lookup(&list, "layout", &layout);
1946         stemp->typeinfo->ext_interface.call(C, ptr, func, &list);
1947
1948         RNA_parameter_list_free(&list);
1949 }
1950
1951 static void rna_NodeSocketInterface_draw_color(bContext *C, PointerRNA *ptr, float *r_color)
1952 {
1953         extern FunctionRNA rna_NodeSocketInterface_draw_color_func;
1954
1955         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1956         ParameterList list;
1957         FunctionRNA *func;
1958         void *ret;
1959
1960         if (!sock->typeinfo)
1961                 return;
1962
1963         func = &rna_NodeSocketInterface_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
1964
1965         RNA_parameter_list_create(&list, ptr, func);
1966         RNA_parameter_set_lookup(&list, "context", &C);
1967         sock->typeinfo->ext_interface.call(C, ptr, func, &list);
1968
1969         RNA_parameter_get_lookup(&list, "color", &ret);
1970         copy_v4_v4(r_color, (float *)ret);
1971
1972         RNA_parameter_list_free(&list);
1973 }
1974
1975 static void rna_NodeSocketInterface_register_properties(bNodeTree *ntree, bNodeSocket *stemp, StructRNA *data_srna)
1976 {
1977         extern FunctionRNA rna_NodeSocketInterface_register_properties_func;
1978
1979         PointerRNA ptr;
1980         ParameterList list;
1981         FunctionRNA *func;
1982
1983         if (!stemp->typeinfo)
1984                 return;
1985
1986         RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
1987         func = &rna_NodeSocketInterface_register_properties_func; /* RNA_struct_find_function(&ptr, "register_properties"); */
1988
1989         RNA_parameter_list_create(&list, &ptr, func);
1990         RNA_parameter_set_lookup(&list, "data_rna_type", &data_srna);
1991         stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
1992
1993         RNA_parameter_list_free(&list);
1994 }
1995
1996 static void rna_NodeSocketInterface_init_socket(bNodeTree *ntree, bNodeSocket *stemp, bNode *node, bNodeSocket *sock, const char *data_path)
1997 {
1998         extern FunctionRNA rna_NodeSocketInterface_init_socket_func;
1999
2000         PointerRNA ptr, node_ptr, sock_ptr;
2001         ParameterList list;
2002         FunctionRNA *func;
2003
2004         if (!stemp->typeinfo)
2005                 return;
2006
2007         RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
2008         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
2009         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr);
2010         func = &rna_NodeSocketInterface_init_socket_func; /* RNA_struct_find_function(&ptr, "init_socket"); */
2011
2012         RNA_parameter_list_create(&list, &ptr, func);
2013         RNA_parameter_set_lookup(&list, "node", &node_ptr);
2014         RNA_parameter_set_lookup(&list, "socket", &sock_ptr);
2015         RNA_parameter_set_lookup(&list, "data_path", &data_path);
2016         stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2017
2018         RNA_parameter_list_free(&list);
2019 }
2020
2021 static void rna_NodeSocketInterface_from_socket(bNodeTree *ntree, bNodeSocket *stemp, bNode *node, bNodeSocket *sock)
2022 {
2023         extern FunctionRNA rna_NodeSocketInterface_from_socket_func;
2024
2025         PointerRNA ptr, node_ptr, sock_ptr;
2026         ParameterList list;
2027         FunctionRNA *func;
2028
2029         if (!stemp->typeinfo)
2030                 return;
2031
2032         RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
2033         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
2034         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr);
2035         func = &rna_NodeSocketInterface_from_socket_func; /* RNA_struct_find_function(&ptr, "from_socket"); */
2036
2037         RNA_parameter_list_create(&list, &ptr, func);
2038         RNA_parameter_set_lookup(&list, "node", &node_ptr);
2039         RNA_parameter_set_lookup(&list, "socket", &sock_ptr);
2040         stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2041
2042         RNA_parameter_list_free(&list);
2043 }
2044
2045 static void rna_NodeSocketInterface_unregister(Main *UNUSED(bmain), StructRNA *type)
2046 {
2047         bNodeSocketType *st = RNA_struct_blender_type_get(type);
2048         if (!st)
2049                 return;
2050         
2051         RNA_struct_free_extension(type, &st->ext_interface);
2052         
2053         RNA_struct_free(&BLENDER_RNA, type);
2054         
2055         /* update while blender is running */
2056         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2057 }
2058
2059 static StructRNA *rna_NodeSocketInterface_register(
2060         Main *UNUSED(bmain), ReportList *UNUSED(reports), void *data, const char *identifier,
2061         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
2062 {
2063         bNodeSocketType *st, dummyst;
2064         bNodeSocket dummysock;
2065         PointerRNA dummyptr;
2066         int have_function[5];
2067
2068         /* setup dummy socket & socket type to store static properties in */
2069         memset(&dummyst, 0, sizeof(bNodeSocketType));
2070         
2071         memset(&dummysock, 0, sizeof(bNodeSocket));
2072         dummysock.typeinfo = &dummyst;
2073         RNA_pointer_create(NULL, &RNA_NodeSocketInterface, &dummysock, &dummyptr);
2074
2075         /* validate the python class */
2076         if (validate(&dummyptr, data, have_function) != 0)
2077                 return NULL;
2078
2079         /* check if we have registered this socket type before */
2080         st = nodeSocketTypeFind(dummyst.idname);
2081         if (st) {
2082                 /* basic socket type registered by a socket class before. */
2083         }
2084         else {
2085                 /* create a new node socket type */
2086                 st = MEM_callocN(sizeof(bNodeSocketType), "node socket type");
2087                 memcpy(st, &dummyst, sizeof(dummyst));
2088                 
2089                 nodeRegisterSocketType(st);
2090         }
2091         
2092         /* if RNA type is already registered, unregister first */
2093         if (st->ext_interface.srna) {
2094                 StructRNA *srna = st->ext_interface.srna;
2095                 RNA_struct_free_extension(srna, &st->ext_interface);
2096                 RNA_struct_free(&BLENDER_RNA, srna);
2097         }
2098         st->ext_interface.srna = RNA_def_struct_ptr(&BLENDER_RNA, identifier, &RNA_NodeSocketInterface); 
2099         st->ext_interface.data = data;
2100         st->ext_interface.call = call;
2101         st->ext_interface.free = free;
2102         RNA_struct_blender_type_set(st->ext_interface.srna, st);
2103         
2104         st->interface_draw = (have_function[0]) ? rna_NodeSocketInterface_draw : NULL;
2105         st->interface_draw_color = (have_function[1]) ? rna_NodeSocketInterface_draw_color : NULL;
2106         st->interface_register_properties = (have_function[2]) ? rna_NodeSocketInterface_register_properties : NULL;
2107         st->interface_init_socket = (have_function[3]) ? rna_NodeSocketInterface_init_socket : NULL;
2108         st->interface_from_socket = (have_function[4]) ? rna_NodeSocketInterface_from_socket : NULL;
2109         
2110         /* update while blender is running */
2111         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2112         
2113         return st->ext_interface.srna;
2114 }
2115
2116 static StructRNA *rna_NodeSocketInterface_refine(PointerRNA *ptr)
2117 {
2118         bNodeSocket *sock = (bNodeSocket *)ptr->data;
2119         
2120         if (sock->typeinfo && sock->typeinfo->ext_interface.srna)
2121                 return sock->typeinfo->ext_interface.srna;
2122         else
2123                 return &RNA_NodeSocketInterface;
2124 }
2125
2126 static char *rna_NodeSocketInterface_path(PointerRNA *ptr)
2127 {
2128         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2129         bNodeSocket *sock = (bNodeSocket *)ptr->data;
2130         int socketindex;
2131         
2132         socketindex = BLI_findindex(&ntree->inputs, sock);
2133         if (socketindex != -1)
2134                 return BLI_sprintfN("inputs[%d]", socketindex);
2135         
2136         socketindex = BLI_findindex(&ntree->outputs, sock);
2137         if (socketindex != -1)
2138                 return BLI_sprintfN("outputs[%d]", socketindex);
2139         
2140         return NULL;
2141 }
2142
2143 static IDProperty *rna_NodeSocketInterface_idprops(PointerRNA *ptr, bool create)
2144 {
2145         bNodeSocket *sock = ptr->data;
2146         
2147         if (create && !sock->prop) {
2148                 IDPropertyTemplate val = {0};
2149                 sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocketInterface ID properties");
2150         }
2151         
2152         return sock->prop;
2153 }
2154
2155 static void rna_NodeSocketInterface_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2156 {
2157         bNodeTree *ntree = ptr->id.data;
2158         bNodeSocket *stemp = ptr->data;
2159         
2160         if (!stemp->typeinfo)
2161                 return;
2162         
2163         ntree->update |= NTREE_UPDATE_GROUP;
2164         ntreeUpdateTree(G.main, ntree);
2165         
2166         ED_node_tag_update_nodetree(bmain, ntree);
2167 }
2168
2169
2170 /* ******** Standard Node Socket Base Types ******** */
2171
2172 static void rna_NodeSocketStandard_draw(ID *id, bNodeSocket *sock, struct bContext *C, struct uiLayout *layout, PointerRNA *nodeptr,
2173                                         const char *text)
2174 {
2175         PointerRNA ptr;
2176         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2177         sock->typeinfo->draw(C, layout, &ptr, nodeptr, text);
2178 }
2179
2180 static void rna_NodeSocketStandard_draw_color(ID *id, bNodeSocket *sock, struct bContext *C, PointerRNA *nodeptr, float *r_color)
2181 {
2182         PointerRNA ptr;
2183         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2184         sock->typeinfo->draw_color(C, &ptr, nodeptr, r_color);
2185 }
2186
2187 static void rna_NodeSocketInterfaceStandard_draw(ID *id, bNodeSocket *sock, struct bContext *C, struct uiLayout *layout)
2188 {
2189         PointerRNA ptr;
2190         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2191         sock->typeinfo->interface_draw(C, layout, &ptr);
2192 }
2193
2194 static void rna_NodeSocketInterfaceStandard_draw_color(ID *id, bNodeSocket *sock, struct bContext *C, float *r_color)
2195 {
2196         PointerRNA ptr;
2197         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2198         sock->typeinfo->interface_draw_color(C, &ptr, r_color);
2199 }
2200
2201 static void rna_NodeSocketStandard_float_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
2202 {
2203         bNodeSocket *sock = ptr->data;
2204         bNodeSocketValueFloat *dval = sock->default_value;
2205         int subtype = sock->typeinfo->subtype;
2206         
2207         if (dval->max < dval->min) {
2208                 dval->max = dval->min;
2209         }
2210         
2211         *min = (subtype == PROP_UNSIGNED ? 0.0f : -FLT_MAX);
2212         *max = FLT_MAX;
2213         *softmin = dval->min;
2214         *softmax = dval->max;
2215 }
2216
2217 static void rna_NodeSocketStandard_int_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
2218 {
2219         bNodeSocket *sock = ptr->data;
2220         bNodeSocketValueInt *dval = sock->default_value;
2221         int subtype = sock->typeinfo->subtype;
2222         
2223         if (dval->max < dval->min) {
2224                 dval->max = dval->min;
2225         }
2226         
2227         *min = (subtype == PROP_UNSIGNED ? 0 : INT_MIN);
2228         *max = INT_MAX;
2229         *softmin = dval->min;
2230         *softmax = dval->max;
2231 }
2232
2233 static void rna_NodeSocketStandard_vector_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
2234 {
2235         bNodeSocket *sock = ptr->data;
2236         bNodeSocketValueVector *dval = sock->default_value;
2237         
2238         if (dval->max < dval->min) {
2239                 dval->max = dval->min;
2240         }
2241         
2242         *min = -FLT_MAX;
2243         *max = FLT_MAX;
2244         *softmin = dval->min;
2245         *softmax = dval->max;
2246 }
2247
2248 /* using a context update function here, to avoid searching the node if possible */
2249 static void rna_NodeSocketStandard_value_update(struct bContext *C, PointerRNA *ptr)
2250 {
2251         bNode *node;
2252         
2253         /* default update */
2254         rna_NodeSocket_update(CTX_data_main(C), CTX_data_scene(C), ptr);
2255         
2256         /* try to use node from context, faster */
2257         node = CTX_data_pointer_get(C, "node").data;
2258         if (!node) {
2259                 bNodeTree *ntree = ptr->id.data;
2260                 bNodeSocket *sock = ptr->data;
2261                 
2262                 /* fall back to searching node in the tree */
2263                 nodeFindNode(ntree, sock, &node, NULL);
2264         }
2265         
2266         if (node) {
2267                 nodeSynchronizeID(node, true);
2268
2269                 /* extra update for sockets that get synced to material */
2270                 if (node->id && ELEM(node->type, SH_NODE_MATERIAL, SH_NODE_MATERIAL_EXT))
2271                         WM_main_add_notifier(NC_MATERIAL | ND_SHADING_DRAW, node->id);
2272         }
2273 }
2274
2275
2276 /* ******** Node Types ******** */
2277
2278 static void rna_NodeInternalSocketTemplate_name_get(PointerRNA *ptr, char *value)
2279 {
2280         bNodeSocketTemplate *stemp = ptr->data;
2281         strcpy(value, stemp->name);
2282 }
2283
2284 static int rna_NodeInternalSocketTemplate_name_length(PointerRNA *ptr)
2285 {
2286         bNodeSocketTemplate *stemp = ptr->data;
2287         return strlen(stemp->name);
2288 }
2289
2290 static void rna_NodeInternalSocketTemplate_identifier_get(PointerRNA *ptr, char *value)
2291 {
2292         bNodeSocketTemplate *stemp = ptr->data;
2293         strcpy(value, stemp->identifier);
2294 }
2295
2296 static int rna_NodeInternalSocketTemplate_identifier_length(PointerRNA *ptr)
2297 {
2298         bNodeSocketTemplate *stemp = ptr->data;
2299         return strlen(stemp->identifier);
2300 }
2301
2302 static int rna_NodeInternalSocketTemplate_type_get(PointerRNA *ptr)
2303 {
2304         bNodeSocketTemplate *stemp = ptr->data;
2305         return stemp->type;
2306 }
2307
2308 static PointerRNA rna_NodeInternal_input_template(StructRNA *srna, int index)
2309 {
2310         bNodeType *ntype = RNA_struct_blender_type_get(srna);
2311         if (ntype && ntype->inputs) {
2312                 bNodeSocketTemplate *stemp = ntype->inputs;
2313                 int i = 0;
2314                 while (i < index && stemp->type >= 0) {
2315                         ++i;
2316                         ++stemp;
2317                 }
2318                 if (i == index && stemp->type >= 0) {
2319                         PointerRNA ptr;
2320                         RNA_pointer_create(NULL, &RNA_NodeInternalSocketTemplate, stemp, &ptr);
2321                         return ptr;
2322                 }
2323         }
2324         return PointerRNA_NULL;
2325 }
2326
2327 static PointerRNA rna_NodeInternal_output_template(StructRNA *srna, int index)
2328 {
2329         bNodeType *ntype = RNA_struct_blender_type_get(srna);
2330         if (ntype && ntype->outputs) {
2331                 bNodeSocketTemplate *stemp = ntype->outputs;
2332                 int i = 0;
2333                 while (i < index && stemp->type >= 0) {
2334                         ++i;
2335                         ++stemp;
2336                 }
2337                 if (i == index && stemp->type >= 0) {
2338                         PointerRNA ptr;
2339                         RNA_pointer_create(NULL, &RNA_NodeInternalSocketTemplate, stemp, &ptr);
2340                         return ptr;
2341                 }
2342         }
2343         return PointerRNA_NULL;
2344 }
2345
2346 static int rna_NodeInternal_poll(StructRNA *srna, bNodeTree *ntree)
2347 {
2348         bNodeType *ntype = RNA_struct_blender_type_get(srna);
2349         return ntype && (!ntype->poll || ntype->poll(ntype, ntree));
2350 }
2351
2352 static int rna_NodeInternal_poll_instance(bNode *node, bNodeTree *ntree)
2353 {
2354         bNodeType *ntype = node->typeinfo;
2355         if (ntype->poll_instance) {
2356                 return ntype->poll_instance(node, ntree);
2357         }
2358         else {
2359                 /* fall back to basic poll function */
2360                 return !ntype->poll || ntype->poll(ntype, ntree);
2361         }
2362 }
2363
2364 static void rna_NodeInternal_update(ID *id, bNode *node)
2365 {
2366         bNodeTree *ntree = (bNodeTree *)id;
2367         if (node->typeinfo->updatefunc)
2368                 node->typeinfo->updatefunc(ntree, node);
2369 }
2370
2371 static void rna_NodeInternal_draw_buttons(ID *id, bNode *node, struct bContext *C, struct uiLayout *layout)
2372 {
2373         if (node->typeinfo->draw_buttons) {
2374                 PointerRNA ptr;
2375                 RNA_pointer_create(id, &RNA_Node, node, &ptr);
2376                 node->typeinfo->draw_buttons(layout, C, &ptr);
2377         }
2378 }
2379
2380 static void rna_NodeInternal_draw_buttons_ext(ID *id, bNode *node, struct bContext *C, struct uiLayout *layout)
2381 {
2382         if (node->typeinfo->draw_buttons_ex) {
2383                 PointerRNA ptr;
2384                 RNA_pointer_create(id, &RNA_Node, node, &ptr);
2385                 node->typeinfo->draw_buttons_ex(layout, C, &ptr);
2386         }
2387         else if (node->typeinfo->draw_buttons) {
2388                 PointerRNA ptr;
2389                 RNA_pointer_create(id, &RNA_Node, node, &ptr);
2390                 node->typeinfo->draw_buttons(layout, C, &ptr);
2391         }
2392 }
2393
2394 static StructRNA *rna_NodeCustomGroup_register(
2395         Main *bmain, ReportList *reports,
2396         void *data, const char *identifier,
2397         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
2398 {
2399         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_NodeCustomGroup, data, identifier, validate, call, free);
2400         if (!nt)
2401                 return NULL;
2402         
2403         /* this updates the group node instance from the tree's interface */
2404         nt->verifyfunc = node_group_verify;
2405         
2406         nodeRegisterType(nt);
2407         
2408         /* update while blender is running */
2409         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2410         
2411         return nt->ext.srna;
2412 }
2413
2414 static void rna_CompositorNode_tag_need_exec(bNode *node)
2415 {
2416         node->need_exec = true;
2417 }
2418
2419 static void rna_Node_tex_image_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2420 {
2421         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2422
2423         ED_node_tag_update_nodetree(bmain, ntree);
2424         WM_main_add_notifier(NC_IMAGE, NULL);
2425 }
2426
2427 static void rna_Node_material_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2428 {
2429         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2430         bNode *node = (bNode *)ptr->data;
2431
2432         if (node->id)
2433                 nodeSetActive(ntree, node);
2434
2435         ED_node_tag_update_nodetree(bmain, ntree);
2436 }
2437
2438 static void rna_NodeGroup_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2439 {
2440         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2441         bNode *node = (bNode *)ptr->data;
2442         
2443         if (node->id)
2444                 ntreeUpdateTree(bmain, (bNodeTree *)node->id);
2445         
2446         ED_node_tag_update_nodetree(bmain, ntree);
2447 }
2448
2449 static void rna_NodeGroup_node_tree_set(PointerRNA *ptr, const PointerRNA value)
2450 {
2451         bNodeTree *ntree = ptr->id.data;
2452         bNode *node = ptr->data;
2453         bNodeTree *ngroup = value.data;
2454         
2455         if (nodeGroupPoll(ntree, ngroup)) {
2456                 if (node->id)
2457                         id_us_min(node->id);
2458                 if (ngroup)
2459                         id_us_plus(&ngroup->id);
2460                 
2461                 node->id = &ngroup->id;
2462         }
2463 }
2464
2465 static int rna_NodeGroup_node_tree_poll(PointerRNA *ptr, const PointerRNA value)
2466 {
2467         bNodeTree *ntree = ptr->id.data;
2468         bNodeTree *ngroup = value.data;
2469         
2470         /* only allow node trees of the same type as the group node's tree */
2471         if (ngroup->type != ntree->type)
2472                 return false;
2473         
2474         return nodeGroupPoll(ntree, ngroup);
2475 }
2476
2477
2478 static StructRNA *rna_NodeGroup_interface_typef(PointerRNA *ptr)
2479 {
2480         bNode *node = ptr->data;
2481         bNodeTree *ngroup = (bNodeTree *)node->id;
2482
2483         if (ngroup) {
2484                 StructRNA *srna = ntreeInterfaceTypeGet(ngroup, true);
2485                 if (srna)
2486                         return srna;
2487         }
2488         return &RNA_PropertyGroup;
2489 }
2490
2491 static StructRNA *rna_NodeGroupInputOutput_interface_typef(PointerRNA *ptr)
2492 {
2493         bNodeTree *ntree = ptr->id.data;
2494         
2495         if (ntree) {
2496                 StructRNA *srna = ntreeInterfaceTypeGet(ntree, true);
2497                 if (srna)
2498                         return srna;
2499         }
2500         return &RNA_PropertyGroup;
2501 }
2502
2503 static void rna_distance_matte_t1_set(PointerRNA *ptr, float value)
2504 {
2505         bNode *node = (bNode *)ptr->data;
2506         NodeChroma *chroma = node->storage;
2507
2508         chroma->t1 = value;
2509 }
2510
2511 static void rna_distance_matte_t2_set(PointerRNA *ptr, float value)
2512 {
2513         bNode *node = (bNode *)ptr->data;
2514         NodeChroma *chroma = node->storage;
2515
2516         chroma->t2 = value;
2517 }
2518
2519 static void rna_difference_matte_t1_set(PointerRNA *ptr, float value)
2520 {
2521         bNode *node = (bNode *)ptr->data;
2522         NodeChroma *chroma = node->storage;
2523
2524         chroma->t1 = value;
2525 }
2526
2527 static void rna_difference_matte_t2_set(PointerRNA *ptr, float value)
2528 {
2529         bNode *node = (bNode *)ptr->data;
2530         NodeChroma *chroma = node->storage;
2531
2532         chroma->t2 = value;
2533 }
2534
2535 /* Button Set Funcs for Matte Nodes */
2536 static void rna_Matte_t1_set(PointerRNA *ptr, float value)
2537 {
2538         bNode *node = (bNode *)ptr->data;
2539         NodeChroma *chroma = node->storage;
2540         
2541         chroma->t1 = value;
2542         
2543         if (value < chroma->t2) 
2544                 chroma->t2 = value;
2545 }
2546
2547 static void rna_Matte_t2_set(PointerRNA *ptr, float value)
2548 {
2549         bNode *node = (bNode *)ptr->data;
2550         NodeChroma *chroma = node->storage;
2551         
2552         if (value > chroma->t1) 
2553                 value = chroma->t1;
2554         
2555         chroma->t2 = value;
2556 }
2557
2558 static void rna_Node_scene_set(PointerRNA *ptr, PointerRNA value)
2559 {
2560         bNode *node = (bNode *)ptr->data;
2561
2562         if (node->id) {
2563                 id_us_min(node->id);
2564                 node->id = NULL;
2565         }
2566
2567         node->id = value.data;
2568
2569         id_us_plus(node->id);
2570 }
2571
2572 static void rna_Node_image_layer_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2573 {
2574         bNode *node = (bNode *)ptr->data;
2575         Image *ima = (Image *)node->id;
2576         ImageUser *iuser = node->storage;
2577         
2578         BKE_image_multilayer_index(ima->rr, iuser);
2579         BKE_image_signal(ima, iuser, IMA_SIGNAL_SRC_CHANGE);
2580         
2581         rna_Node_update(bmain, scene, ptr);
2582 }
2583
2584 static EnumPropertyItem *renderresult_layers_add_enum(RenderLayer *rl)
2585 {
2586         EnumPropertyItem *item = NULL;
2587         EnumPropertyItem tmp = {0, "", 0, "", ""};
2588         int i = 0, totitem = 0;
2589         
2590         while (rl) {
2591                 tmp.identifier = rl->name;
2592                 /* little trick: using space char instead empty string makes the item selectable in the dropdown */
2593                 if (rl->name[0] == '\0')
2594                         tmp.name = " ";
2595                 else
2596                         tmp.name = rl->name;
2597                 tmp.value = i++;
2598                 RNA_enum_item_add(&item, &totitem, &tmp);
2599                 rl = rl->next;
2600         }
2601         
2602         RNA_enum_item_end(&item, &totitem);
2603
2604         return item;
2605 }
2606
2607 static EnumPropertyItem *rna_Node_image_layer_itemf(bContext *UNUSED(C), PointerRNA *ptr,
2608                                                     PropertyRNA *UNUSED(prop), bool *r_free)
2609 {
2610         bNode *node = (bNode *)ptr->data;
2611         Image *ima = (Image *)node->id;
2612         EnumPropertyItem *item = NULL;
2613         RenderLayer *rl;
2614         
2615         if (ima && ima->rr) {
2616                 rl = ima->rr->layers.first;
2617                 item = renderresult_layers_add_enum(rl);
2618         }
2619         else {
2620                 int totitem = 0;
2621                 RNA_enum_item_end(&item, &totitem);
2622         }
2623         
2624         *r_free = true;
2625         
2626         return item;
2627 }
2628
2629 static int rna_Node_image_has_layers_get(PointerRNA *ptr)
2630 {
2631         bNode *node = (bNode *)ptr->data;
2632         Image *ima = (Image *)node->id;
2633
2634         if (!ima || !(ima->rr)) return 0;
2635
2636         return RE_layers_have_name(ima->rr);
2637 }
2638
2639 static int rna_Node_image_has_views_get(PointerRNA *ptr)
2640 {
2641         bNode *node = (bNode *)ptr->data;
2642         Image *ima = (Image *)node->id;
2643
2644         if (!ima || !(ima->rr)) return 0;
2645
2646         return BLI_listbase_count_ex(&ima->rr->views, 2) > 1;
2647 }
2648
2649 static EnumPropertyItem *renderresult_views_add_enum(RenderView *rv)
2650 {
2651         EnumPropertyItem *item = NULL;
2652         EnumPropertyItem tmp = {0, "ALL", 0, "All", ""};
2653         int i = 1, totitem = 0;
2654
2655         /* option to use all views */
2656         RNA_enum_item_add(&item, &totitem, &tmp);
2657
2658         while (rv) {
2659                 tmp.identifier = rv->name;
2660                 /* little trick: using space char instead empty string makes the item selectable in the dropdown */
2661                 if (rv->name[0] == '\0')
2662                         tmp.name = " ";
2663                 else
2664                         tmp.name = rv->name;
2665                 tmp.value = i++;
2666                 RNA_enum_item_add(&item, &totitem, &tmp);
2667                 rv = rv->next;
2668         }
2669
2670         RNA_enum_item_end(&item, &totitem);
2671
2672         return item;
2673 }
2674
2675 static EnumPropertyItem *rna_Node_image_view_itemf(bContext *UNUSED(C), PointerRNA *ptr,
2676                                                    PropertyRNA *UNUSED(prop), bool *free)
2677 {
2678         bNode *node = (bNode *)ptr->data;
2679         Image *ima = (Image *)node->id;
2680         EnumPropertyItem *item = NULL;
2681         RenderView *rv;
2682
2683         if (!ima || !(ima->rr)) return NULL;
2684
2685         rv = ima->rr->views.first;
2686         item = renderresult_views_add_enum(rv);
2687
2688         *free = true;
2689
2690         return item;
2691 }
2692
2693 static EnumPropertyItem *rna_Node_scene_layer_itemf(bContext *UNUSED(C), PointerRNA *ptr,
2694                                                     PropertyRNA *UNUSED(prop), bool *r_free)
2695 {
2696         bNode *node = (bNode *)ptr->data;
2697         Scene *sce = (Scene *)node->id;
2698         EnumPropertyItem *item = NULL;
2699         RenderLayer *rl;
2700         
2701         if (sce) {
2702                 rl = sce->r.layers.first;
2703                 item = renderresult_layers_add_enum(rl);
2704         }
2705         else {
2706                 int totitem = 0;
2707                 RNA_enum_item_end(&item, &totitem);
2708         }
2709         
2710         *r_free = true;
2711         
2712         return item;
2713 }
2714
2715 static EnumPropertyItem *rna_Node_channel_itemf(bContext *UNUSED(C), PointerRNA *ptr,
2716                                                 PropertyRNA *UNUSED(prop), bool *r_free)
2717 {
2718         bNode *node = (bNode *)ptr->data;
2719         EnumPropertyItem *item = NULL;
2720         EnumPropertyItem tmp = {0, "", 0, "", ""};
2721         int totitem = 0;
2722         
2723         switch (node->custom1) {
2724                 case CMP_NODE_CHANNEL_MATTE_CS_RGB:
2725                         tmp.identifier = "R"; tmp.name = "R"; tmp.value = 1;
2726                         RNA_enum_item_add(&item, &totitem, &tmp);
2727                         tmp.identifier = "G"; tmp.name = "G"; tmp.value = 2;
2728                         RNA_enum_item_add(&item, &totitem, &tmp);
2729                         tmp.identifier = "B"; tmp.name = "B"; tmp.value = 3;
2730                         RNA_enum_item_add(&item, &totitem, &tmp);
2731                         break;
2732                 case CMP_NODE_CHANNEL_MATTE_CS_HSV:
2733                         tmp.identifier = "H"; tmp.name = "H"; tmp.value = 1;
2734                         RNA_enum_item_add(&item, &totitem, &tmp);
2735                         tmp.identifier = "S"; tmp.name = "S"; tmp.value = 2;
2736                         RNA_enum_item_add(&item, &totitem, &tmp);
2737                         tmp.identifier = "V"; tmp.name = "V"; tmp.value = 3;
2738                         RNA_enum_item_add(&item, &totitem, &tmp);
2739                         break;
2740                 case CMP_NODE_CHANNEL_MATTE_CS_YUV:
2741                         tmp.identifier = "Y"; tmp.name = "Y"; tmp.value = 1;
2742                         RNA_enum_item_add(&item, &totitem, &tmp);
2743                         tmp.identifier = "G"; tmp.name = "U"; tmp.value = 2;
2744                         RNA_enum_item_add(&item, &totitem, &tmp);
2745                         tmp.identifier = "V"; tmp.name = "V"; tmp.value = 3;
2746                         RNA_enum_item_add(&item, &totitem, &tmp);
2747                         break;
2748                 case CMP_NODE_CHANNEL_MATTE_CS_YCC:
2749                         tmp.identifier = "Y"; tmp.name = "Y"; tmp.value = 1;
2750                         RNA_enum_item_add(&item, &totitem, &tmp);
2751                         tmp.identifier = "CB"; tmp.name = "Cr"; tmp.value = 2;
2752                         RNA_enum_item_add(&item, &totitem, &tmp);
2753                         tmp.identifier = "CR"; tmp.name = "Cb"; tmp.value = 3;
2754                         RNA_enum_item_add(&item, &totitem, &tmp);
2755                         break;
2756                 default:
2757                         break;
2758         }
2759
2760         RNA_enum_item_end(&item, &totitem);
2761         *r_free = true;
2762         
2763         return item;
2764 }
2765
2766 static void rna_Image_Node_update_id(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
2767 {
2768         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2769         bNode *node = (bNode *)ptr->data;
2770
2771         node->update |= NODE_UPDATE_ID;
2772         nodeUpdate(ntree, node);        /* to update image node sockets */
2773 }
2774
2775 static void rna_Mapping_Node_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2776 {
2777         bNode *node = ptr->data;
2778         BKE_texture_mapping_init(node->storage);
2779         rna_Node_update(bmain, scene, ptr);
2780 }
2781
2782 static void rna_NodeOutputFile_slots_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
2783 {
2784         bNode *node = ptr->data;
2785         rna_iterator_listbase_begin(iter, &node->inputs, NULL);
2786 }
2787
2788 static PointerRNA rna_NodeOutputFile_slot_file_get(CollectionPropertyIterator *iter)
2789 {
2790         PointerRNA ptr;
2791         bNodeSocket *sock = rna_iterator_listbase_get(iter);
2792         RNA_pointer_create(iter->parent.id.data, &RNA_NodeOutputFileSlotFile, sock->storage, &ptr);
2793         return ptr;
2794 }
2795
2796 static void rna_NodeColorBalance_update_lgg(Main *bmain, Scene *scene, PointerRNA *ptr)
2797 {
2798         ntreeCompositColorBalanceSyncFromLGG(ptr->id.data, ptr->data);
2799         rna_Node_update(bmain, scene, ptr);
2800 }
2801
2802 static void rna_NodeColorBalance_update_cdl(Main *bmain, Scene *scene, PointerRNA *ptr)
2803 {
2804         ntreeCompositColorBalanceSyncFromCDL(ptr->id.data, ptr->data);
2805         rna_Node_update(bmain, scene, ptr);
2806 }
2807
2808 /* ******** Node Socket Types ******** */
2809
2810 static PointerRNA rna_NodeOutputFile_slot_layer_get(CollectionPropertyIterator *iter)
2811 {
2812         PointerRNA ptr;
2813         bNodeSocket *sock = rna_iterator_listbase_get(iter);
2814         RNA_pointer_create(iter->parent.id.data, &RNA_NodeOutputFileSlotLayer, sock->storage, &ptr);
2815         return ptr;
2816 }
2817
2818 static int rna_NodeOutputFileSocket_find_node(bNodeTree *ntree, NodeImageMultiFileSocket *data, bNode **nodep, bNodeSocket **sockp)
2819 {
2820         bNode *node;
2821         bNodeSocket *sock;
2822         
2823         for (node = ntree->nodes.first; node; node = node->next) {
2824                 for (sock = node->inputs.first; sock; sock = sock->next) {
2825                         NodeImageMultiFileSocket *sockdata = sock->storage;
2826                         if (sockdata == data) {
2827                                 *nodep = node;
2828                                 *sockp = sock;
2829                                 return 1;
2830                         }
2831                 }
2832         }
2833         
2834         *nodep = NULL;
2835         *sockp = NULL;
2836         return 0;
2837 }
2838
2839 static void rna_NodeOutputFileSlotFile_path_set(PointerRNA *ptr, const char *value)
2840 {
2841         bNodeTree *ntree = ptr->id.data;
2842         NodeImageMultiFileSocket *sockdata = ptr->data;
2843         bNode *node;
2844         bNodeSocket *sock;
2845         
2846         if (rna_NodeOutputFileSocket_find_node(ntree, sockdata, &node, &sock)) {
2847                 ntreeCompositOutputFileSetPath(node, sock, value);
2848         }
2849 }
2850
2851 static void rna_NodeOutputFileSlotLayer_name_set(PointerRNA *ptr, const char *value)
2852 {
2853         bNodeTree *ntree = ptr->id.data;
2854         NodeImageMultiFileSocket *sockdata = ptr->data;
2855         bNode *node;
2856         bNodeSocket *sock;
2857         
2858         if (rna_NodeOutputFileSocket_find_node(ntree, sockdata, &node, &sock)) {
2859                 ntreeCompositOutputFileSetLayer(node, sock, value);
2860         }
2861 }
2862
2863 static bNodeSocket *rna_NodeOutputFile_slots_new(ID *id, bNode *node, bContext *C, ReportList *UNUSED(reports), const char *name)
2864 {
2865         bNodeTree *ntree = (bNodeTree *)id;
2866         Scene *scene = CTX_data_scene(C);
2867         ImageFormatData *im_format = NULL;
2868         bNodeSocket *sock;
2869         if (scene)
2870                 im_format = &scene->r.im_format;
2871         
2872         sock = ntreeCompositOutputFileAddSocket(ntree, node, name, im_format);
2873         
2874         ntreeUpdateTree(CTX_data_main(C), ntree);
2875         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2876         
2877         return sock;
2878 }
2879
2880 static void rna_ShaderNodeScript_mode_set(PointerRNA *ptr, int value)
2881 {
2882         bNode *node = (bNode *)ptr->data;
2883         NodeShaderScript *nss = node->storage;
2884
2885         if (nss->mode != value) {
2886                 nss->mode = value;
2887                 nss->filepath[0] = '\0';
2888                 nss->flag &= ~NODE_SCRIPT_AUTO_UPDATE;
2889
2890                 /* replace text data-block by filepath */
2891                 if (node->id) {
2892                         Text *text = (Text *)node->id;
2893
2894                         if (value == NODE_SCRIPT_EXTERNAL && text->name) {
2895                                 BLI_strncpy(nss->filepath, text->name, sizeof(nss->filepath));
2896                                 BLI_path_rel(nss->filepath, G.main->name);
2897                         }
2898
2899                         id_us_min(node->id);
2900                         node->id = NULL;
2901                 }
2902
2903                 /* remove any bytecode */
2904                 if (nss->bytecode) {
2905                         MEM_freeN(nss->bytecode);
2906                         nss->bytecode = NULL;
2907                 }
2908
2909                 nss->bytecode_hash[0] = '\0';
2910         }
2911 }
2912
2913 static void rna_ShaderNodeScript_bytecode_get(PointerRNA *ptr, char *value)
2914 {
2915         bNode *node = (bNode *)ptr->data;
2916         NodeShaderScript *nss = node->storage;
2917
2918         strcpy(value, (nss->bytecode) ? nss->bytecode : "");
2919 }
2920
2921 static int rna_ShaderNodeScript_bytecode_length(PointerRNA *ptr)
2922 {
2923         bNode *node = (bNode *)ptr->data;
2924         NodeShaderScript *nss = node->storage;
2925
2926         return (nss->bytecode) ? strlen(nss->bytecode) : 0;
2927 }
2928
2929 static void rna_ShaderNodeScript_bytecode_set(PointerRNA *ptr, const char *value)
2930 {
2931         bNode *node = (bNode *)ptr->data;
2932         NodeShaderScript *nss = node->storage;
2933
2934         if (nss->bytecode)
2935                 MEM_freeN(nss->bytecode);
2936
2937         if (value && value[0])
2938                 nss->bytecode = BLI_strdup(value);
2939         else
2940                 nss->bytecode = NULL;
2941 }
2942
2943 static void rna_ShaderNodeScript_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2944 {
2945         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2946         bNode *node = (bNode *)ptr->data;
2947         RenderEngineType *engine_type = RE_engines_find(scene->r.engine);
2948
2949         if (engine_type && engine_type->update_script_node) {
2950                 /* auto update node */
2951                 RenderEngine *engine = RE_engine_create(engine_type);
2952                 engine_type->update_script_node(engine, ntree, node);
2953                 RE_engine_free(engine);
2954         }
2955
2956         ED_node_tag_update_nodetree(bmain, ntree);
2957 }
2958
2959 static void rna_ShaderNodeSubsurface_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2960 {
2961         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2962         bNode *node = (bNode *)ptr->data;
2963
2964         nodeUpdate(ntree, node);
2965         rna_Node_update(bmain, scene, ptr);
2966 }
2967
2968 static void rna_CompositorNodeScale_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2969 {
2970         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2971         bNode *node = (bNode *)ptr->data;
2972
2973         nodeUpdate(ntree, node);
2974         rna_Node_update(bmain, scene, ptr);
2975 }
2976
2977 static PointerRNA rna_ShaderNodePointDensity_psys_get(PointerRNA *ptr)
2978 {
2979         bNode *node = ptr->data;
2980         NodeShaderTexPointDensity *shader_point_density = node->storage;
2981         Object *ob = (Object *)node->id;
2982         ParticleSystem *psys = NULL;
2983         PointerRNA value;
2984
2985         if (ob && shader_point_density->particle_system) {
2986                 psys = BLI_findlink(&ob->particlesystem, shader_point_density->particle_system - 1);
2987         }
2988
2989         RNA_pointer_create(&ob->id, &RNA_ParticleSystem, psys, &value);
2990         return value;
2991 }
2992
2993 static void rna_ShaderNodePointDensity_psys_set(PointerRNA *ptr, PointerRNA value)
2994 {
2995         bNode *node = ptr->data;
2996         NodeShaderTexPointDensity *shader_point_density = node->storage;
2997         Object *ob = (Object *)node->id;
2998
2999         if (ob && value.id.data == ob) {
3000                 shader_point_density->particle_system = BLI_findindex(&ob->particlesystem, value.data) + 1;
3001         }
3002         else {
3003                 shader_point_density->particle_system = 0;
3004         }
3005 }
3006
3007 static int point_density_color_source_from_shader(NodeShaderTexPointDensity *shader_point_density)
3008 {
3009         switch (shader_point_density->color_source) {
3010                 case SHD_POINTDENSITY_COLOR_PARTAGE: return TEX_PD_COLOR_PARTAGE;
3011                 case SHD_POINTDENSITY_COLOR_PARTSPEED: return TEX_PD_COLOR_PARTSPEED;
3012                 case SHD_POINTDENSITY_COLOR_PARTVEL: return TEX_PD_COLOR_PARTVEL;
3013                 default:
3014                         BLI_assert(!"Unknown color source");
3015                         return TEX_PD_COLOR_CONSTANT;
3016         }
3017 }
3018
3019 void rna_ShaderNodePointDensity_density_calc(bNode *self,
3020                                              Scene *scene,
3021                                              int settings,
3022                                              int *length,
3023                                              float **values)
3024 {
3025         NodeShaderTexPointDensity *shader_point_density = self->storage;
3026         PointDensity pd;
3027
3028         if (scene == NULL) {
3029                 *length = 0;
3030                 return;
3031         }
3032
3033         *length = 4 * shader_point_density->resolution *
3034                       shader_point_density->resolution *
3035                       shader_point_density->resolution;
3036
3037         if (*values == NULL) {
3038                 *values = MEM_mallocN(sizeof(float) * (*length), "point density dynamic array");
3039         }
3040
3041         /* Create PointDensity structure from node for sampling. */
3042         BKE_texture_pointdensity_init_data(&pd);
3043         pd.object = (Object *)self->id;
3044         pd.radius = shader_point_density->radius;
3045         if (shader_point_density->point_source == SHD_POINTDENSITY_SOURCE_PSYS) {
3046                 pd.source = TEX_PD_PSYS;
3047                 pd.psys = shader_point_density->particle_system;
3048                 pd.psys_cache_space = TEX_PD_OBJECTSPACE;
3049         }
3050         else {
3051                 BLI_assert(shader_point_density->point_source == SHD_POINTDENSITY_SOURCE_OBJECT);
3052                 pd.source = TEX_PD_OBJECT;
3053                 pd.ob_cache_space = TEX_PD_OBJECTSPACE;
3054         }
3055         pd.color_source = point_density_color_source_from_shader(shader_point_density);
3056
3057         /* Single-threaded sampling of the voxel domain. */
3058         RE_sample_point_density(scene, &pd,
3059                                 shader_point_density->resolution,
3060                                 settings == 1,
3061                                 *values);
3062
3063         /* We're done, time to clean up. */
3064         BKE_texture_pointdensity_free_data(&pd);
3065 }
3066
3067 #else
3068
3069 static EnumPropertyItem prop_image_layer_items[] = {
3070         { 0, "PLACEHOLDER",          0, "Placeholder",          ""},
3071         {0, NULL, 0, NULL, NULL}
3072 };
3073
3074 static EnumPropertyItem prop_image_view_items[] = {
3075         { 0, "ALL", 0, "All", ""},
3076         {0, NULL, 0, NULL, NULL}
3077 };
3078
3079 static EnumPropertyItem prop_scene_layer_items[] = {
3080         { 0, "PLACEHOLDER",          0, "Placeholder",          ""},
3081         {0, NULL, 0, NULL, NULL}
3082 };
3083
3084 static EnumPropertyItem prop_tri_channel_items[] = {
3085         { 1, "R", 0, "R", ""},
3086         { 2, "G", 0, "G", ""},
3087         { 3, "B", 0, "B", ""},
3088         {0, NULL, 0, NULL, NULL}
3089 };
3090
3091 static EnumPropertyItem node_flip_items[] = {
3092         {0, "X",  0, "Flip X",     ""},
3093         {1, "Y",  0, "Flip Y",     ""},
3094         {2, "XY", 0, "Flip X & Y", ""},
3095         {0, NULL, 0, NULL, NULL}
3096 };
3097
3098 static EnumPropertyItem node_ycc_items[] = {
3099         { 0, "ITUBT601", 0, "ITU 601",  ""},
3100         { 1, "ITUBT709", 0, "ITU 709",  ""},
3101         { 2, "JFIF",     0, "Jpeg",     ""},
3102         {0, NULL, 0, NULL, NULL}
3103 };
3104
3105 static EnumPropertyItem node_glossy_items[] = {
3106         {SHD_GLOSSY_SHARP,             "SHARP",             0, "Sharp",    ""},
3107         {SHD_GLOSSY_BECKMANN,          "BECKMANN",          0, "Beckmann", ""},
3108         {SHD_GLOSSY_GGX,               "GGX",               0, "GGX",      ""},
3109         {SHD_GLOSSY_ASHIKHMIN_SHIRLEY, "ASHIKHMIN_SHIRLEY", 0, "Ashikhmin-Shirley", ""},
3110         {0, NULL, 0, NULL, NULL}
3111 };
3112
3113 static EnumPropertyItem node_anisotropic_items[] = {
3114         {SHD_GLOSSY_BECKMANN,          "BECKMANN",          0, "Beckmann", ""},
3115         {SHD_GLOSSY_GGX,               "GGX",               0, "GGX",      ""},
3116         {SHD_GLOSSY_ASHIKHMIN_SHIRLEY, "ASHIKHMIN_SHIRLEY", 0, "Ashikhmin-Shirley", ""},
3117         {0, NULL, 0, NULL, NULL}
3118 };
3119
3120 static EnumPropertyItem node_glass_items[] = {
3121         {SHD_GLOSSY_SHARP,             "SHARP",             0, "Sharp",    ""},
3122         {SHD_GLOSSY_BECKMANN,          "BECKMANN",          0, "Beckmann", ""},
3123         {SHD_GLOSSY_GGX,               "GGX",               0, "GGX",      ""},
3124         {0, NULL, 0, NULL, NULL}
3125 };
3126
3127 static EnumPropertyItem node_toon_items[] = {
3128         {SHD_TOON_DIFFUSE,    "DIFFUSE",  0, "Diffuse", ""},
3129         {SHD_TOON_GLOSSY,     "GLOSSY",   0, "Glossy",  ""},
3130         {0, NULL, 0, NULL, NULL}
3131 };
3132
3133 static EnumPropertyItem node_hair_items[] = {
3134         {SHD_HAIR_REFLECTION,     "Reflection",    0,   "Reflection", ""},
3135         {SHD_HAIR_TRANSMISSION,   "Transmission",    0,  "Transmission", ""},
3136         {0, NULL, 0, NULL, NULL}
3137 };
3138
3139 static EnumPropertyItem node_script_mode_items[] = {
3140         {NODE_SCRIPT_INTERNAL, "INTERNAL", 0, "Internal", "Use internal text data-block"},
3141         {NODE_SCRIPT_EXTERNAL, "EXTERNAL", 0, "External", "Use external .osl or .oso file"},
3142         {0, NULL, 0, NULL, NULL}
3143 };
3144
3145 /* -- Common nodes ---------------------------------------------------------- */
3146
3147 static void def_group_input(StructRNA *srna)
3148 {
3149         PropertyRNA *prop;
3150         
3151         prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
3152         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroupInputOutput_interface_typef", NULL);
3153         RNA_def_property_struct_type(prop, "PropertyGroup");
3154         RNA_def_property_flag(prop, PROP_IDPROPERTY);
3155         RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
3156 }
3157
3158 static void def_group_output(StructRNA *srna)
3159 {
3160         PropertyRNA *prop;
3161         
3162         prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
3163         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroupInputOutput_interface_typef", NULL);
3164         RNA_def_property_struct_type(prop, "PropertyGroup");
3165         RNA_def_property_flag(prop, PROP_IDPROPERTY);
3166         RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
3167         
3168         prop = RNA_def_property(srna, "is_active_output", PROP_BOOLEAN, PROP_NONE);
3169         RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_DO_OUTPUT);
3170         RNA_def_property_ui_text(prop, "Active Output", "True if this node is used as the active group output");
3171         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3172 }
3173
3174 static void def_group(StructRNA *srna)
3175 {
3176         PropertyRNA *prop;
3177         
3178         prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
3179         RNA_def_property_pointer_sdna(prop, NULL, "id");
3180         RNA_def_property_struct_type(prop, "NodeTree");
3181         RNA_def_property_pointer_funcs(prop, NULL, "rna_NodeGroup_node_tree_set", NULL, "rna_NodeGroup_node_tree_poll");
3182         RNA_def_property_flag(prop, PROP_EDITABLE);
3183         RNA_def_property_ui_text(prop, "Node Tree", "");
3184         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeGroup_update");
3185
3186         prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
3187         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroup_interface_typef", NULL);
3188         RNA_def_property_struct_type(prop, "PropertyGroup");
3189         RNA_def_property_flag(prop, PROP_IDPROPERTY);
3190         RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
3191 }
3192
3193 static void def_custom_group(BlenderRNA *brna)
3194 {
3195         StructRNA *srna;
3196         
3197         srna = RNA_def_struct(brna, "NodeCustomGroup", "Node");
3198         RNA_def_struct_ui_text(srna, "Custom Group", "Base node type for custom registered node group types");
3199         RNA_def_struct_sdna(srna, "bNode");
3200
3201         RNA_def_struct_register_funcs(srna, "rna_NodeCustomGroup_register", "rna_Node_unregister", NULL);
3202
3203         def_group(srna);
3204 }
3205
3206 static void def_frame(StructRNA *srna)
3207 {
3208         PropertyRNA *prop; 
3209         
3210         prop = RNA_def_property(srna, "text", PROP_POINTER, PROP_NONE);
3211         RNA_def_property_pointer_sdna(prop, NULL, "id");
3212         RNA_def_property_struct_type(prop, "Text");
3213         RNA_def_property_flag(prop, PROP_EDITABLE);
3214         RNA_def_property_ui_text(prop, "Text", "");
3215         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3216
3217         RNA_def_struct_sdna_from(srna, "NodeFrame", "storage");
3218         
3219         prop = RNA_def_property(srna, "shrink", PROP_BOOLEAN, PROP_NONE);
3220         RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_FRAME_SHRINK);
3221         RNA_def_property_ui_text(prop, "Shrink", "Shrink the frame to minimal bounding box");
3222         RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL);
3223
3224         prop = RNA_def_property(srna, "label_size", PROP_INT, PROP_NONE);
3225         RNA_def_property_int_sdna(prop, NULL, "label_size");
3226         RNA_def_property_range(prop, 8, 64);
3227         RNA_def_property_ui_text(prop, "Label Font Size", "Font size to use for displaying the label");
3228         RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL);
3229 }
3230
3231 static void def_math(StructRNA *srna)
3232 {
3233         PropertyRNA *prop;
3234         
3235         prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
3236         RNA_def_property_enum_sdna(prop, NULL, "custom1");
3237         RNA_def_property_enum_items(prop, rna_enum_node_math_items);
3238         RNA_def_property_ui_text(prop, "Operation", "");
3239         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3240
3241         prop = RNA_def_property(srna, "use_clamp", PROP_BOOLEAN, PROP_NONE);
3242         RNA_def_property_boolean_sdna(prop, NULL, "custom2", SHD_MATH_CLAMP);
3243         RNA_def_property_ui_text(prop, "Clamp", "Clamp result of the node to 0..1 range");
3244         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3245 }
3246
3247 static void def_vector_math(StructRNA *srna)
3248 {
3249         PropertyRNA *prop;
3250         
3251         prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
3252         RNA_def_property_enum_sdna(prop, NULL, "custom1");
3253         RNA_def_property_enum_items(prop, rna_enum_node_vec_math_items);
3254         RNA_def_property_ui_text(prop, "Operation", "");
3255         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3256 }
3257
3258 static void def_rgb_curve(StructRNA *srna)
3259 {
3260         PropertyRNA *prop;
3261         
3262         prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
3263         RNA_def_property_pointer_sdna(prop, NULL, "storage");
3264         RNA_def_property_struct_type(prop, "CurveMapping");
3265         RNA_def_property_ui_text(prop, "Mapping", "");
3266         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3267 }
3268
3269 static void def_vector_curve(StructRNA *srna)
3270 {
3271         PropertyRNA *prop;
3272         
3273         prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
3274         RNA_def_property_pointer_sdna(prop, NULL, "storage");
3275         RNA_def_property_struct_type(prop, "CurveMapping");
3276         RNA_def_property_ui_text(prop, "Mapping", "");
3277         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3278 }
3279
3280 static void def_time(StructRNA *srna)
3281 {
3282         PropertyRNA *prop;
3283         
3284         prop = RNA_def_property(srna, "curve", PROP_POINTER, PROP_NONE);
3285         RNA_def_property_pointer_sdna(prop, NULL, "storage");
3286         RNA_def_property_struct_type(prop, "CurveMapping");
3287         RNA_def_property_ui_text(prop, "Curve", "");
3288         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3289         
3290         prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_NONE);
3291         RNA_def_property_int_sdna(prop, NULL, "custom1");
3292         RNA_def_property_ui_text(prop, "Start Frame", "");
3293         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3294         
3295         prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_NONE);
3296         RNA_def_property_int_sdna(prop, NULL, "custom2");
3297         RNA_def_property_ui_text(prop, "End Frame", "");
3298         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3299 }
3300
3301 static void def_colorramp(StructRNA *srna)
3302 {
3303         PropertyRNA *prop;
3304         
3305         prop = RNA_def_property(srna, "color_ramp", PROP_POINTER, PROP_NONE);
3306         RNA_def_property_pointer_sdna(prop, NULL, "storage");
3307         RNA_def_property_struct_type(prop, "ColorRamp");
3308         RNA_def_property_ui_text(prop, "Color Ramp", "");
3309         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3310 }
3311
3312 static void def_mix_rgb(StructRNA *srna)
3313 {
3314         PropertyRNA *prop;
3315         
3316         prop = RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
3317         RNA_def_property_enum_sdna(prop, NULL, "custom1");
3318         RNA_def_property_enum_items(prop, rna_enum_ramp_blend_items);
3319         RNA_def_property_ui_text(prop, "Blend Type", "");
3320         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3321         
3322         prop = RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
3323         RNA_def_property_boolean_sdna(prop, NULL, "custom2", SHD_MIXRGB_USE_ALPHA);
3324         RNA_def_property_ui_text(prop, "Alpha", "Include alpha of second input in this operation");
3325         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3326
3327         prop = RNA_def_property(srna, "use_clamp", PROP_BOOLEAN, PROP_NONE);
3328         RNA_def_property_boolean_sdna(prop, NULL, "custom2", SHD_MIXRGB_CLAMP);
3329         RNA_def_property_ui_text(prop, "Clamp", "Clamp result of the node to 0..1 range");
3330         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3331 }
3332
3333 static void def_texture(StructRNA *srna)
3334 {
3335         PropertyRNA *prop;
3336         
3337         prop = RNA_def_property(srna, "texture", PROP_POINTER, PROP_NONE);
3338         RNA_def_property_pointer_sdna(prop, NULL, "id");
3339         RNA_def_property_struct_type(prop, "Texture");
3340         RNA_def_property_flag(prop, PROP_EDITABLE);
3341         RNA_def_property_ui_text(prop, "Texture", "");
3342         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3343         
3344         prop = RNA_def_property(srna, "node_output", PROP_INT, PROP_NONE);
3345         RNA_def_property_int_sdna(prop, NULL, "custom1");
3346         RNA_def_property_ui_text(prop, "Node Output", "For node-based textures, which output node to use");
3347         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3348 }
3349
3350
3351 /* -- Shader Nodes ---------------------------------------------------------- */
3352
3353 static void def_sh_output(StructRNA *srna)
3354 {
3355         PropertyRNA *prop;
3356         
3357         prop = RNA_def_property(srna, "is_active_output", PROP_BOOLEAN, PROP_NONE);
3358         RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_DO_OUTPUT);
3359         RNA_def_property_ui_text(prop, "Active Output", "True if this node is used as the active output");
3360         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3361 }
3362
3363 static void def_sh_output_linestyle(StructRNA *srna)
3364 {
3365         def_sh_output(srna);
3366         def_mix_rgb(srna);
3367 }
3368
3369 static void def_sh_material(StructRNA *srna)
3370 {
3371         PropertyRNA *prop;
3372
3373         prop = RNA_def_property(srna, "material", PROP_POINTER, PROP_NONE);
3374         RNA_def_property_pointer_sdna(prop, NULL, "id");
3375         RNA_def_property_struct_type(prop, "Material");
3376         RNA_def_property_flag(prop, PROP_EDITABLE);
3377         RNA_def_property_ui_text(prop, "Material", "");
3378         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_material_update");
3379
3380         prop = RNA_def_property(srna, "use_diffuse", PROP_BOOLEAN, PROP_NONE);
3381         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_DIFF);
3382         RNA_def_property_ui_text(prop, "Diffuse", "Material Node outputs Diffuse");
3383         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3384
3385         prop = RNA_def_property(srna, "use_specular", PROP_BOOLEAN, PROP_NONE);
3386         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_SPEC);
3387         RNA_def_property_ui_text(prop, "Specular", "Material Node outputs Specular");
3388         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3389         
3390         prop = RNA_def_property(srna, "invert_normal", PROP_BOOLEAN, PROP_NONE);
3391         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_NEG);
3392         RNA_def_property_ui_text(prop, "Invert Normal", "Material Node uses inverted normal");
3393         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3394 }
3395
3396 static void def_sh_mapping(StructRNA *srna)
3397 {
3398         static EnumPropertyItem prop_vect_type_items[] = {
3399                 {TEXMAP_TYPE_TEXTURE, "TEXTURE", 0, "Texture", "Transform a texture by inverse mapping the texture coordinate"},
3400                 {TEXMAP_TYPE_POINT,   "POINT",   0, "Point",   "Transform a point"},
3401                 {TEXMAP_TYPE_VECTOR,  "VECTOR",  0, "Vector",  "Transform a direction vector"},
3402                 {TEXMAP_TYPE_NORMAL,  "NORMAL",  0, "Normal",  "Transform a normal vector with unit length"},
3403                 {0, NULL, 0, NULL, NULL}
3404         };
3405
3406         static float default_1[3] = {1.f, 1.f, 1.f};
3407
3408         PropertyRNA *prop;
3409         
3410         RNA_def_struct_sdna_from(srna, "TexMapping", "storage");
3411
3412         prop = RNA_def_property(srna, "vector_type", PROP_ENUM, PROP_NONE);
3413         RNA_def_property_enum_sdna(prop, NULL, "type");
3414         RNA_def_property_enum_items(prop, prop_vect_type_items);
3415         RNA_def_property_ui_text(prop, "Type", "Type of vector that the mapping transforms");
3416         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3417
3418         prop = RNA_def_property(srna, "translation", PROP_FLOAT, PROP_TRANSLATION);
3419         RNA_def_property_float_sdna(prop, NULL, "loc");
3420         RNA_def_property_ui_text(prop, "Location", "");
3421         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3422         
3423         /* Not PROP_XYZ, this is now in radians, no more degrees */
3424         prop = RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_EULER);
3425         RNA_def_property_float_sdna(prop, NULL, "rot");