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