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