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