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