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