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