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