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