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