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