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