Custom Group Node type for extending existing nodes from python scripts. This is...
[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         /* XXX ugly stuff, should be done with specialized operators (after actual node creation)! */
728         if (ntree->type == NTREE_COMPOSIT) {
729                 if (ELEM4(node->type, CMP_NODE_COMPOSITE, CMP_NODE_DEFOCUS, CMP_NODE_OUTPUT_FILE, CMP_NODE_R_LAYERS)) {
730                         /* annoying, find the node tree we are in, scene can be NULL */
731                         Scene *scene;
732                         for (scene = CTX_data_main(C)->scene.first; scene; scene = scene->id.next) {
733                                 if (scene->nodetree == ntree) {
734                                         break;
735                                 }
736                         }
737                         node->id = (ID *)scene;
738                         id_us_plus(node->id);
739                 }
740                 
741                 ntreeCompositForceHidden(ntree, CTX_data_scene(C));
742         }
743         else if (ntree->type == NTREE_TEXTURE) {
744                 ntreeTexCheckCyclics(ntree);
745         }
746         
747         ntreeUpdateTree(CTX_data_main(C), ntree);
748         nodeUpdate(ntree, node);
749         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
750
751         return node;
752 }
753
754 static void rna_NodeTree_node_remove(bNodeTree *ntree, ReportList *reports, PointerRNA *node_ptr)
755 {
756         bNode *node = node_ptr->data;
757         
758         if (!rna_NodeTree_check(ntree, reports))
759                 return;
760         
761         if (BLI_findindex(&ntree->nodes, node) == -1) {
762                 BKE_reportf(reports, RPT_ERROR, "Unable to locate node '%s' in node tree", node->name);
763                 return;
764         }
765
766         id_us_min(node->id);
767         nodeFreeNode(ntree, node);
768         RNA_POINTER_INVALIDATE(node_ptr);
769
770         ntreeUpdateTree(G.main, ntree); /* update group node socket links */
771         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
772 }
773
774 static void rna_NodeTree_node_clear(bNodeTree *ntree, ReportList *reports)
775 {
776         bNode *node = ntree->nodes.first;
777
778         if (!rna_NodeTree_check(ntree, reports))
779                 return;
780
781         while (node) {
782                 bNode *next_node = node->next;
783
784                 if (node->id)
785                         id_us_min(node->id);
786
787                 nodeFreeNode(ntree, node);
788
789                 node = next_node;
790         }
791
792         ntreeUpdateTree(G.main, ntree);
793
794         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
795 }
796
797 static PointerRNA rna_NodeTree_active_node_get(PointerRNA *ptr)
798 {
799         bNodeTree *ntree = (bNodeTree *)ptr->data;
800         bNode *node = nodeGetActive(ntree);
801         return rna_pointer_inherit_refine(ptr, &RNA_Node, node);
802 }
803
804 static void rna_NodeTree_active_node_set(PointerRNA *ptr, const PointerRNA value)
805 {
806         bNodeTree *ntree = (bNodeTree *)ptr->data;
807         bNode *node = (bNode *)value.data;
808         
809         if (node && BLI_findindex(&ntree->nodes, node) != -1)
810                 nodeSetActive(ntree, node);
811         else
812                 nodeClearActive(ntree);
813 }
814
815 static bNodeLink *rna_NodeTree_link_new(bNodeTree *ntree, ReportList *reports,
816                                         bNodeSocket *fromsock, bNodeSocket *tosock,
817                                         int verify_limits)
818 {
819         bNodeLink *ret;
820         bNode *fromnode = NULL, *tonode = NULL;
821
822         if (!rna_NodeTree_check(ntree, reports))
823                 return NULL;
824
825         nodeFindNode(ntree, fromsock, &fromnode, NULL);
826         nodeFindNode(ntree, tosock, &tonode, NULL);
827         
828         if (&fromsock->in_out == &tosock->in_out) {
829                 BKE_report(reports, RPT_ERROR, "Same input/output direction of sockets");
830                 return NULL;
831         }
832
833         if (verify_limits) {
834                 /* remove other socket links if limit is exceeded */
835                 if (nodeCountSocketLinks(ntree, fromsock) + 1 > fromsock->limit)
836                         nodeRemSocketLinks(ntree, fromsock);
837                 if (nodeCountSocketLinks(ntree, tosock) + 1 > tosock->limit)
838                         nodeRemSocketLinks(ntree, tosock);
839         }
840
841         ret = nodeAddLink(ntree, fromnode, fromsock, tonode, tosock);
842         
843         if (ret) {
844                 if (tonode)
845                         nodeUpdate(ntree, tonode);
846
847                 ntreeUpdateTree(G.main, ntree);
848
849                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
850         }
851         return ret;
852 }
853
854 static void rna_NodeTree_link_remove(bNodeTree *ntree, ReportList *reports, PointerRNA *link_ptr)
855 {
856         bNodeLink *link = link_ptr->data;
857
858         if (!rna_NodeTree_check(ntree, reports))
859                 return;
860
861         if (BLI_findindex(&ntree->links, link) == -1) {
862                 BKE_report(reports, RPT_ERROR, "Unable to locate link in node tree");
863                 return;
864         }
865
866         nodeRemLink(ntree, link);
867         RNA_POINTER_INVALIDATE(link_ptr);
868
869         ntreeUpdateTree(G.main, ntree);
870         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
871 }
872
873 static void rna_NodeTree_link_clear(bNodeTree *ntree, ReportList *reports)
874 {
875         bNodeLink *link = ntree->links.first;
876
877         if (!rna_NodeTree_check(ntree, reports))
878                 return;
879
880         while (link) {
881                 bNodeLink *next_link = link->next;
882
883                 nodeRemLink(ntree, link);
884
885                 link = next_link;
886         }
887         ntreeUpdateTree(G.main, ntree);
888
889         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
890 }
891
892 static int rna_NodeTree_active_input_get(PointerRNA *ptr)
893 {
894         bNodeTree *ntree = (bNodeTree *)ptr->data;
895         bNodeSocket *gsock;
896         int index;
897
898         for (gsock = ntree->inputs.first, index = 0; gsock; gsock = gsock->next, ++index)
899                 if (gsock->flag & SELECT)
900                         return index;
901         return -1;
902 }
903
904 static void rna_NodeTree_active_input_set(PointerRNA *ptr, int value)
905 {
906         bNodeTree *ntree = (bNodeTree *)ptr->data;
907         bNodeSocket *gsock;
908         int index;
909         
910         for (gsock = ntree->inputs.first, index = 0; gsock; gsock = gsock->next, ++index) {
911                 if (index == value)
912                         gsock->flag |= SELECT;
913                 else
914                         gsock->flag &= ~SELECT;
915         }
916         for (gsock = ntree->outputs.first; gsock; gsock = gsock->next) {
917                 gsock->flag &= ~SELECT;
918         }
919 }
920
921 static int rna_NodeTree_active_output_get(PointerRNA *ptr)
922 {
923         bNodeTree *ntree = (bNodeTree *)ptr->data;
924         bNodeSocket *gsock;
925         int index;
926
927         for (gsock = ntree->outputs.first, index = 0; gsock; gsock = gsock->next, ++index)
928                 if (gsock->flag & SELECT)
929                         return index;
930         return -1;
931 }
932
933 static void rna_NodeTree_active_output_set(PointerRNA *ptr, int value)
934 {
935         bNodeTree *ntree = (bNodeTree *)ptr->data;
936         bNodeSocket *gsock;
937         int index;
938         
939         for (gsock = ntree->inputs.first; gsock; gsock = gsock->next) {
940                 gsock->flag &= ~SELECT;
941         }
942         for (gsock = ntree->outputs.first, index = 0; gsock; gsock = gsock->next, ++index) {
943                 if (index == value)
944                         gsock->flag |= SELECT;
945                 else
946                         gsock->flag &= ~SELECT;
947         }
948 }
949
950 static int rna_NodeTree_inputs_lookupstring(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
951 {
952         bNodeTree *ntree = (bNodeTree *)ptr->data;
953         bNodeSocket *sock = ntreeFindSocketInterface(ntree, SOCK_IN, key);
954         RNA_pointer_create(ptr->id.data, &RNA_NodeSocketInterface, sock, r_ptr);
955         return (sock != NULL);
956 }
957
958 static int rna_NodeTree_outputs_lookupstring(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
959 {
960         bNodeTree *ntree = (bNodeTree *)ptr->data;
961         bNodeSocket *sock = ntreeFindSocketInterface(ntree, SOCK_OUT, key);
962         RNA_pointer_create(ptr->id.data, &RNA_NodeSocketInterface, sock, r_ptr);
963         return (sock != NULL);
964 }
965
966 static bNodeSocket *rna_NodeTree_inputs_new(bNodeTree *ntree, ReportList *reports, const char *type, const char *name)
967 {
968         bNodeSocket *sock;
969         
970         if (!rna_NodeTree_check(ntree, reports))
971                 return NULL;
972         
973         sock = ntreeAddSocketInterface(ntree, SOCK_IN, type, name);
974         
975         ntreeUpdateTree(G.main, ntree);
976         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
977         
978         return sock;
979 }
980
981 static bNodeSocket *rna_NodeTree_outputs_new(bNodeTree *ntree, ReportList *reports, const char *type, const char *name)
982 {
983         bNodeSocket *sock;
984         
985         if (!rna_NodeTree_check(ntree, reports))
986                 return NULL;
987         
988         sock = ntreeAddSocketInterface(ntree, SOCK_OUT, type, name);
989         
990         ntreeUpdateTree(G.main, ntree);
991         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
992         
993         return sock;
994 }
995
996 static void rna_NodeTree_socket_remove(bNodeTree *ntree, ReportList *reports, bNodeSocket *sock)
997 {
998         if (!rna_NodeTree_check(ntree, reports))
999                 return;
1000         
1001         if (BLI_findindex(&ntree->inputs, sock) == -1 && BLI_findindex(&ntree->outputs, sock) == -1) {
1002                 BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier);
1003         }
1004         else {
1005                 ntreeRemoveSocketInterface(ntree, sock);
1006                 
1007                 ntreeUpdateTree(G.main, ntree);
1008                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1009         }
1010 }
1011
1012 static void rna_NodeTree_inputs_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->inputs.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_outputs_clear(bNodeTree *ntree, ReportList *reports)
1029 {
1030         bNodeSocket *sock, *nextsock;
1031         
1032         if (!rna_NodeTree_check(ntree, reports))
1033                 return;
1034         
1035         for (sock = ntree->outputs.first; sock; sock = nextsock) {
1036                 nextsock = sock->next;
1037                 ntreeRemoveSocketInterface(ntree, sock);
1038         }
1039
1040         ntreeUpdateTree(G.main, ntree);
1041         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1042 }
1043
1044 static void rna_NodeTree_interface_update(bNodeTree *ntree, bContext *C)
1045 {
1046         ntree->update |= NTREE_UPDATE_GROUP;
1047         ntreeUpdateTree(G.main, ntree);
1048         
1049         ED_node_tag_update_nodetree(CTX_data_main(C), ntree);
1050 }
1051
1052
1053 /* ******** NodeLink ******** */
1054
1055 static int rna_NodeLink_is_hidden_get(PointerRNA *ptr)
1056 {
1057         bNodeLink *link = ptr->data;
1058         return nodeLinkIsHidden(link);
1059 }
1060
1061
1062 /* ******** Node ******** */
1063
1064 static StructRNA *rna_Node_refine(struct PointerRNA *ptr)
1065 {
1066         bNode *node = (bNode *)ptr->data;
1067         
1068         if (node->typeinfo->ext.srna)
1069                 return node->typeinfo->ext.srna;
1070         else
1071                 return ptr->type;
1072 }
1073
1074 static char *rna_Node_path(PointerRNA *ptr)
1075 {
1076         bNode *node = (bNode *)ptr->data;
1077         char name_esc[sizeof(node->name) * 2];
1078
1079         BLI_strescape(name_esc, node->name, sizeof(name_esc));
1080         return BLI_sprintfN("nodes[\"%s\"]", name_esc);
1081 }
1082
1083 static int rna_Node_poll(bNodeType *ntype, bNodeTree *ntree)
1084 {
1085         extern FunctionRNA rna_Node_poll_func;
1086
1087         PointerRNA ptr;
1088         ParameterList list;
1089         FunctionRNA *func;
1090         void *ret;
1091         int visible;
1092
1093         RNA_pointer_create(NULL, ntype->ext.srna, NULL, &ptr); /* dummy */
1094         func = &rna_Node_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */
1095
1096         RNA_parameter_list_create(&list, &ptr, func);
1097         RNA_parameter_set_lookup(&list, "node_tree", &ntree);
1098         ntype->ext.call(NULL, &ptr, func, &list);
1099
1100         RNA_parameter_get_lookup(&list, "visible", &ret);
1101         visible = *(int *)ret;
1102
1103         RNA_parameter_list_free(&list);
1104
1105         return visible;
1106 }
1107
1108 static int rna_Node_poll_instance(bNode *node, bNodeTree *ntree)
1109 {
1110         extern FunctionRNA rna_Node_poll_instance_func;
1111
1112         PointerRNA ptr;
1113         ParameterList list;
1114         FunctionRNA *func;
1115         void *ret;
1116         int visible;
1117
1118         RNA_pointer_create(NULL, node->typeinfo->ext.srna, node, &ptr); /* dummy */
1119         func = &rna_Node_poll_instance_func; /* RNA_struct_find_function(&ptr, "poll_instance"); */
1120
1121         RNA_parameter_list_create(&list, &ptr, func);
1122         RNA_parameter_set_lookup(&list, "node_tree", &ntree);
1123         node->typeinfo->ext.call(NULL, &ptr, func, &list);
1124
1125         RNA_parameter_get_lookup(&list, "visible", &ret);
1126         visible = *(int *)ret;
1127
1128         RNA_parameter_list_free(&list);
1129
1130         return visible;
1131 }
1132
1133 static int rna_Node_poll_instance_default(bNode *node, bNodeTree *ntree)
1134 {
1135         /* use the basic poll function */
1136         return rna_Node_poll(node->typeinfo, ntree);
1137 }
1138
1139 static void rna_Node_update_reg(bNodeTree *ntree, bNode *node)
1140 {
1141         extern FunctionRNA rna_Node_update_func;
1142
1143         PointerRNA ptr;
1144         ParameterList list;
1145         FunctionRNA *func;
1146
1147         RNA_pointer_create((ID *)ntree, node->typeinfo->ext.srna, node, &ptr);
1148         func = &rna_Node_update_func; /* RNA_struct_find_function(&ptr, "update"); */
1149
1150         RNA_parameter_list_create(&list, &ptr, func);
1151         node->typeinfo->ext.call(NULL, &ptr, func, &list);
1152
1153         RNA_parameter_list_free(&list);
1154 }
1155
1156 static void rna_Node_init(const bContext *C, PointerRNA *ptr)
1157 {
1158         extern FunctionRNA rna_Node_init_func;
1159
1160         bNode *node = (bNode *)ptr->data;
1161         ParameterList list;
1162         FunctionRNA *func;
1163
1164         func = &rna_Node_init_func; /* RNA_struct_find_function(&ptr, "init"); */
1165
1166         RNA_parameter_list_create(&list, ptr, func);
1167         node->typeinfo->ext.call((bContext *)C, ptr, func, &list);
1168
1169         RNA_parameter_list_free(&list);
1170 }
1171
1172 static void rna_Node_copy(PointerRNA *ptr, struct bNode *copynode)
1173 {
1174         extern FunctionRNA rna_Node_copy_func;
1175
1176         bNode *node = (bNode *)ptr->data;
1177         ParameterList list;
1178         FunctionRNA *func;
1179
1180         func = &rna_Node_copy_func; /* RNA_struct_find_function(&ptr, "copy"); */
1181
1182         RNA_parameter_list_create(&list, ptr, func);
1183         RNA_parameter_set_lookup(&list, "node", &copynode);
1184         node->typeinfo->ext.call(NULL, ptr, func, &list);
1185
1186         RNA_parameter_list_free(&list);
1187 }
1188
1189 static void rna_Node_free(PointerRNA *ptr)
1190 {
1191         extern FunctionRNA rna_Node_free_func;
1192
1193         bNode *node = (bNode *)ptr->data;
1194         ParameterList list;
1195         FunctionRNA *func;
1196
1197         func = &rna_Node_free_func; /* RNA_struct_find_function(&ptr, "free"); */
1198
1199         RNA_parameter_list_create(&list, ptr, func);
1200         node->typeinfo->ext.call(NULL, ptr, func, &list);
1201
1202         RNA_parameter_list_free(&list);
1203 }
1204
1205 static void rna_Node_draw_buttons(struct uiLayout *layout, bContext *C, PointerRNA *ptr)
1206 {
1207         extern FunctionRNA rna_Node_draw_buttons_func;
1208
1209         bNode *node = (bNode *)ptr->data;
1210         ParameterList list;
1211         FunctionRNA *func;
1212
1213         func = &rna_Node_draw_buttons_func; /* RNA_struct_find_function(&ptr, "draw_buttons"); */
1214
1215         RNA_parameter_list_create(&list, ptr, func);
1216         RNA_parameter_set_lookup(&list, "context", &C);
1217         RNA_parameter_set_lookup(&list, "layout", &layout);
1218         node->typeinfo->ext.call(C, ptr, func, &list);
1219
1220         RNA_parameter_list_free(&list);
1221 }
1222
1223 static void rna_Node_draw_buttons_ext(struct uiLayout *layout, bContext *C, PointerRNA *ptr)
1224 {
1225         extern FunctionRNA rna_Node_draw_buttons_ext_func;
1226
1227         bNode *node = (bNode *)ptr->data;
1228         ParameterList list;
1229         FunctionRNA *func;
1230
1231         func = &rna_Node_draw_buttons_ext_func; /* RNA_struct_find_function(&ptr, "draw_buttons_ext"); */
1232
1233         RNA_parameter_list_create(&list, ptr, func);
1234         RNA_parameter_set_lookup(&list, "context", &C);
1235         RNA_parameter_set_lookup(&list, "layout", &layout);
1236         node->typeinfo->ext.call(C, ptr, func, &list);
1237
1238         RNA_parameter_list_free(&list);
1239 }
1240
1241 static int rna_Node_is_registered_node_type(StructRNA *type)
1242 {
1243         return (RNA_struct_blender_type_get(type) != NULL);
1244 }
1245
1246 static void rna_Node_is_registered_node_type_runtime(bContext *UNUSED(C), ReportList *UNUSED(reports), PointerRNA *ptr, ParameterList *parms)
1247 {
1248         int result = (RNA_struct_blender_type_get(ptr->type) != NULL);
1249         RNA_parameter_set_lookup(parms, "result", &result);
1250 }
1251
1252 static void rna_Node_unregister(Main *UNUSED(bmain), StructRNA *type)
1253 {
1254         bNodeType *nt = RNA_struct_blender_type_get(type);
1255
1256         if (!nt)
1257                 return;
1258
1259         RNA_struct_free_extension(type, &nt->ext);
1260
1261         /* this also frees the allocated nt pointer, no MEM_free call needed! */
1262         nodeUnregisterType(nt);
1263
1264         RNA_struct_free(&BLENDER_RNA, type);
1265
1266         /* update while blender is running */
1267         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1268 }
1269
1270 /* Generic internal registration function.
1271  * Can be used to implement callbacks for registerable RNA node subtypes.
1272  */
1273 static bNodeType *rna_Node_register_base(Main *bmain, ReportList *reports, StructRNA *basetype,
1274                                          void *data, const char *identifier,
1275                                          StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1276 {
1277         bNodeType *nt, dummynt;
1278         bNode dummynode;
1279         PointerRNA dummyptr;
1280         FunctionRNA *func;
1281         PropertyRNA *parm;
1282         int have_function[8];
1283
1284         /* setup dummy node & node type to store static properties in */
1285         memset(&dummynt, 0, sizeof(bNodeType));
1286         /* this does some additional initialization of default values */
1287         node_type_base_custom(&dummynt, identifier, "", 0, 0);
1288
1289         memset(&dummynode, 0, sizeof(bNode));
1290         dummynode.typeinfo = &dummynt;
1291         RNA_pointer_create(NULL, basetype, &dummynode, &dummyptr);
1292
1293         /* validate the python class */
1294         if (validate(&dummyptr, data, have_function) != 0)
1295                 return NULL;
1296
1297         if (strlen(identifier) >= sizeof(dummynt.idname)) {
1298                 BKE_reportf(reports, RPT_ERROR, "Registering node class: '%s' is too long, maximum length is %d",
1299                             identifier, (int)sizeof(dummynt.idname));
1300                 return NULL;
1301         }
1302
1303         /* check if we have registered this node type before, and remove it */
1304         nt = nodeTypeFind(dummynt.idname);
1305         if (nt)
1306                 rna_Node_unregister(bmain, nt->ext.srna);
1307         
1308         /* create a new node type */
1309         nt = MEM_callocN(sizeof(bNodeType), "node type");
1310         memcpy(nt, &dummynt, sizeof(dummynt));
1311         /* make sure the node type struct is freed on unregister */
1312         nt->needs_free = 1;
1313
1314         nt->ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, nt->idname, basetype);
1315         nt->ext.data = data;
1316         nt->ext.call = call;
1317         nt->ext.free = free;
1318         RNA_struct_blender_type_set(nt->ext.srna, nt);
1319
1320         RNA_def_struct_ui_text(nt->ext.srna, nt->ui_name, nt->ui_description);
1321         RNA_def_struct_ui_icon(nt->ext.srna, nt->ui_icon);
1322
1323         func = RNA_def_function_runtime(nt->ext.srna, "is_registered_node_type", rna_Node_is_registered_node_type_runtime);
1324         RNA_def_function_ui_description(func, "True if a registered node type");
1325         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_SELF_TYPE);
1326         parm = RNA_def_boolean(func, "result", FALSE, "Result", "");
1327         RNA_def_function_return(func, parm);
1328
1329         /* XXX bad level call! needed to initialize the basic draw functions ... */
1330         ED_init_custom_node_type(nt);
1331
1332         nt->poll = (have_function[0]) ? rna_Node_poll : NULL;
1333         nt->poll_instance = (have_function[1]) ? rna_Node_poll_instance : rna_Node_poll_instance_default;
1334         nt->updatefunc = (have_function[2]) ? rna_Node_update_reg : NULL;
1335         nt->initfunc_api = (have_function[3]) ? rna_Node_init : NULL;
1336         nt->copyfunc_api = (have_function[4]) ? rna_Node_copy : NULL;
1337         nt->freefunc_api = (have_function[5]) ? rna_Node_free : NULL;
1338         nt->uifunc = (have_function[6]) ? rna_Node_draw_buttons : NULL;
1339         nt->uifuncbut = (have_function[7]) ? rna_Node_draw_buttons_ext : NULL;
1340         
1341         /* sanitize size values in case not all have been registered */
1342         if (nt->maxwidth < nt->minwidth)
1343                 nt->maxwidth = nt->minwidth;
1344         if (nt->maxheight < nt->minheight)
1345                 nt->maxheight = nt->minheight;
1346         CLAMP(nt->width, nt->minwidth, nt->maxwidth);
1347         CLAMP(nt->height, nt->minheight, nt->maxheight);
1348         
1349         return nt;
1350 }
1351
1352 static StructRNA *rna_Node_register(Main *bmain, ReportList *reports,
1353                                     void *data, const char *identifier,
1354                                     StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1355 {
1356         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_Node, data, identifier, validate, call, free);
1357         if (!nt)
1358                 return NULL;
1359         
1360         nodeRegisterType(nt);
1361         
1362         /* update while blender is running */
1363         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1364         
1365         return nt->ext.srna;
1366 }
1367
1368 static StructRNA *rna_ShaderNode_register(Main *bmain, ReportList *reports,
1369                                           void *data, const char *identifier,
1370                                           StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1371 {
1372         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_ShaderNode, data, identifier, validate, call, free);
1373         if (!nt)
1374                 return NULL;
1375         
1376         nodeRegisterType(nt);
1377         
1378         /* update while blender is running */
1379         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1380         
1381         return nt->ext.srna;
1382 }
1383
1384 static StructRNA *rna_CompositorNode_register(Main *bmain, ReportList *reports,
1385                                               void *data, const char *identifier,
1386                                               StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1387 {
1388         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_CompositorNode, data, identifier, validate, call, free);
1389         if (!nt)
1390                 return NULL;
1391         
1392         nodeRegisterType(nt);
1393         
1394         /* update while blender is running */
1395         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1396         
1397         return nt->ext.srna;
1398 }
1399
1400 static StructRNA *rna_TextureNode_register(Main *bmain, ReportList *reports,
1401                                            void *data, const char *identifier,
1402                                            StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1403 {
1404         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_TextureNode, data, identifier, validate, call, free);
1405         if (!nt)
1406                 return NULL;
1407         
1408         nodeRegisterType(nt);
1409         
1410         /* update while blender is running */
1411         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1412         
1413         return nt->ext.srna;
1414 }
1415
1416 static IDProperty *rna_Node_idprops(PointerRNA *ptr, bool create)
1417 {
1418         bNode *node = ptr->data;
1419         
1420         if (create && !node->prop) {
1421                 IDPropertyTemplate val = {0};
1422                 node->prop = IDP_New(IDP_GROUP, &val, "RNA_Node ID properties");
1423         }
1424         
1425         return node->prop;
1426 }
1427
1428 static void rna_Node_parent_set(PointerRNA *ptr, PointerRNA value)
1429 {
1430         bNode *node = ptr->data;
1431         bNode *parent = value.data;
1432         
1433         if (parent) {
1434                 /* XXX only Frame node allowed for now,
1435                  * in the future should have a poll function or so to test possible attachment.
1436                  */
1437                 if (parent->type != NODE_FRAME)
1438                         return;
1439                 
1440                 /* make sure parent is not attached to the node */
1441                 if (nodeAttachNodeCheck(parent, node))
1442                         return;
1443         }
1444         
1445         nodeDetachNode(node);
1446         if (parent) {
1447                 nodeAttachNode(node, parent);
1448         }
1449 }
1450
1451 static int rna_Node_parent_poll(PointerRNA *ptr, PointerRNA value)
1452 {
1453         bNode *node = ptr->data;
1454         bNode *parent = value.data;
1455         
1456         /* XXX only Frame node allowed for now,
1457          * in the future should have a poll function or so to test possible attachment.
1458          */
1459         if (parent->type != NODE_FRAME)
1460                 return FALSE;
1461         
1462         /* make sure parent is not attached to the node */
1463         if (nodeAttachNodeCheck(parent, node))
1464                 return FALSE;
1465         
1466         return TRUE;
1467 }
1468
1469 static void rna_Node_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
1470 {
1471         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1472         ED_node_tag_update_nodetree(bmain, ntree);
1473 }
1474
1475 static void rna_Node_socket_value_update(ID *id, bNode *UNUSED(node), bContext *C)
1476 {
1477         ED_node_tag_update_nodetree(CTX_data_main(C), (bNodeTree *)id);
1478 }
1479
1480 static void rna_Node_select_set(PointerRNA *ptr, int value)
1481 {
1482         bNode *node = (bNode *)ptr->data;
1483         nodeSetSelected(node, value);
1484 }
1485
1486 static void rna_Node_name_set(PointerRNA *ptr, const char *value)
1487 {
1488         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1489         bNode *node = (bNode *)ptr->data;
1490         char oldname[sizeof(node->name)];
1491         
1492         /* make a copy of the old name first */
1493         BLI_strncpy(oldname, node->name, sizeof(node->name));
1494         /* set new name */
1495         BLI_strncpy_utf8(node->name, value, sizeof(node->name));
1496         
1497         nodeUniqueName(ntree, node);
1498         
1499         /* fix all the animation data which may link to this */
1500         BKE_all_animdata_fix_paths_rename(NULL, "nodes", oldname, node->name);
1501 }
1502
1503 static int rna_Node_inputs_lookupstring(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
1504 {
1505         bNode *node = (bNode *)ptr->data;
1506         bNodeSocket *sock = nodeFindSocket(node, SOCK_IN, key);
1507         RNA_pointer_create(ptr->id.data, &RNA_NodeSocket, sock, r_ptr);
1508         return (sock != NULL);
1509 }
1510
1511 static int rna_Node_outputs_lookupstring(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
1512 {
1513         bNode *node = (bNode *)ptr->data;
1514         bNodeSocket *sock = nodeFindSocket(node, SOCK_OUT, key);
1515         RNA_pointer_create(ptr->id.data, &RNA_NodeSocket, sock, r_ptr);
1516         return (sock != NULL);
1517 }
1518
1519 static bNodeSocket *rna_Node_inputs_new(ID *id, bNode *node, ReportList *reports, const char *type, const char *name, const char *identifier)
1520 {
1521         bNodeTree *ntree = (bNodeTree *)id;
1522         bNodeSocket *sock;
1523         
1524         sock = nodeAddSocket(ntree, node, SOCK_IN, type, identifier, name);
1525         
1526         if (sock == NULL) {
1527                 BKE_report(reports, RPT_ERROR, "Unable to create socket");
1528         }
1529         else {
1530                 ntreeUpdateTree(G.main, ntree);
1531                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1532         }
1533         
1534         return sock;
1535 }
1536
1537 static bNodeSocket *rna_Node_outputs_new(ID *id, bNode *node, ReportList *reports, const char *type, const char *name, const char *identifier)
1538 {
1539         bNodeTree *ntree = (bNodeTree *)id;
1540         bNodeSocket *sock;
1541         
1542         sock = nodeAddSocket(ntree, node, SOCK_OUT, type, identifier, name);
1543         
1544         if (sock == NULL) {
1545                 BKE_reportf(reports, RPT_ERROR, "Unable to create socket");
1546         }
1547         else {
1548                 ntreeUpdateTree(G.main, ntree);
1549                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1550         }
1551         
1552         return sock;
1553 }
1554
1555 static void rna_Node_socket_remove(ID *id, bNode *node, ReportList *reports, bNodeSocket *sock)
1556 {
1557         bNodeTree *ntree = (bNodeTree *)id;
1558         
1559         if (BLI_findindex(&node->inputs, sock) == -1 && BLI_findindex(&node->outputs, sock) == -1) {
1560                 BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier);
1561         }
1562         else {
1563                 nodeRemoveSocket(ntree, node, sock);
1564                 
1565                 ntreeUpdateTree(G.main, ntree);
1566                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1567         }
1568 }
1569
1570 static void rna_Node_inputs_clear(ID *id, bNode *node)
1571 {
1572         bNodeTree *ntree = (bNodeTree *)id;
1573         bNodeSocket *sock, *nextsock;
1574         
1575         for (sock = node->inputs.first; sock; sock = nextsock) {
1576                 nextsock = sock->next;
1577                 nodeRemoveSocket(ntree, node, sock);
1578         }
1579
1580         ntreeUpdateTree(G.main, ntree);
1581         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1582 }
1583
1584 static void rna_Node_outputs_clear(ID *id, bNode *node)
1585 {
1586         bNodeTree *ntree = (bNodeTree *)id;
1587         bNodeSocket *sock, *nextsock;
1588         
1589         for (sock = node->outputs.first; sock; sock = nextsock) {
1590                 nextsock = sock->next;
1591                 nodeRemoveSocket(ntree, node, sock);
1592         }
1593
1594         ntreeUpdateTree(G.main, ntree);
1595         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1596 }
1597
1598 static void rna_Node_inputs_move(ID *id, bNode *node, int from_index, int to_index)
1599 {
1600         bNodeTree *ntree = (bNodeTree *)id;
1601         bNodeSocket *sock;
1602         
1603         if (from_index == to_index)
1604                 return;
1605         if (from_index < 0 || to_index < 0)
1606                 return;
1607         
1608         sock = BLI_findlink(&node->inputs, from_index);
1609         if (to_index < from_index) {
1610                 bNodeSocket *nextsock = BLI_findlink(&node->inputs, to_index);
1611                 if (nextsock) {
1612                         BLI_remlink(&node->inputs, sock);
1613                         BLI_insertlinkbefore(&node->inputs, nextsock, sock);
1614                 }
1615         }
1616         else {
1617                 bNodeSocket *prevsock = BLI_findlink(&node->inputs, to_index);
1618                 if (prevsock) {
1619                         BLI_remlink(&node->inputs, sock);
1620                         BLI_insertlinkafter(&node->inputs, prevsock, sock);
1621                 }
1622         }
1623         
1624         ntreeUpdateTree(G.main, ntree);
1625         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1626 }
1627
1628 static void rna_Node_outputs_move(ID *id, bNode *node, int from_index, int to_index)
1629 {
1630         bNodeTree *ntree = (bNodeTree *)id;
1631         bNodeSocket *sock;
1632         
1633         if (from_index == to_index)
1634                 return;
1635         if (from_index < 0 || to_index < 0)
1636                 return;
1637         
1638         sock = BLI_findlink(&node->outputs, from_index);
1639         if (to_index < from_index) {
1640                 bNodeSocket *nextsock = BLI_findlink(&node->outputs, to_index);
1641                 if (nextsock) {
1642                         BLI_remlink(&node->outputs, sock);
1643                         BLI_insertlinkbefore(&node->outputs, nextsock, sock);
1644                 }
1645         }
1646         else {
1647                 bNodeSocket *prevsock = BLI_findlink(&node->outputs, to_index);
1648                 if (prevsock) {
1649                         BLI_remlink(&node->outputs, sock);
1650                         BLI_insertlinkafter(&node->outputs, prevsock, sock);
1651                 }
1652         }
1653         
1654         ntreeUpdateTree(G.main, ntree);
1655         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1656 }
1657
1658 static void rna_Node_width_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
1659 {
1660         bNode *node = ptr->data;
1661         *min = *softmin = node->typeinfo->minwidth;
1662         *max = *softmax = node->typeinfo->maxwidth;
1663 }
1664
1665 static void rna_Node_height_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
1666 {
1667         bNode *node = ptr->data;
1668         *min = *softmin = node->typeinfo->minheight;
1669         *max = *softmax = node->typeinfo->maxheight;
1670 }
1671
1672
1673 /* ******** Node Socket ******** */
1674
1675 static void rna_NodeSocket_draw(bContext *C, struct uiLayout *layout, PointerRNA *ptr, PointerRNA *node_ptr, const char *text)
1676 {
1677         extern FunctionRNA rna_NodeSocket_draw_func;
1678
1679         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1680         ParameterList list;
1681         FunctionRNA *func;
1682
1683         func = &rna_NodeSocket_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
1684
1685         RNA_parameter_list_create(&list, ptr, func);
1686         RNA_parameter_set_lookup(&list, "context", &C);
1687         RNA_parameter_set_lookup(&list, "layout", &layout);
1688         RNA_parameter_set_lookup(&list, "node", node_ptr);
1689         RNA_parameter_set_lookup(&list, "text", &text);
1690         sock->typeinfo->ext_socket.call(C, ptr, func, &list);
1691
1692         RNA_parameter_list_free(&list);
1693 }
1694
1695 static void rna_NodeSocket_draw_color(bContext *C, PointerRNA *ptr, PointerRNA *node_ptr, float *r_color)
1696 {
1697         extern FunctionRNA rna_NodeSocket_draw_color_func;
1698
1699         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1700         ParameterList list;
1701         FunctionRNA *func;
1702         void *ret;
1703
1704         func = &rna_NodeSocket_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
1705
1706         RNA_parameter_list_create(&list, ptr, func);
1707         RNA_parameter_set_lookup(&list, "context", &C);
1708         RNA_parameter_set_lookup(&list, "node", node_ptr);
1709         sock->typeinfo->ext_socket.call(C, ptr, func, &list);
1710
1711         RNA_parameter_get_lookup(&list, "color", &ret);
1712         copy_v4_v4(r_color, (float *)ret);
1713
1714         RNA_parameter_list_free(&list);
1715 }
1716
1717 static void rna_NodeSocket_unregister(Main *UNUSED(bmain), StructRNA *type)
1718 {
1719         bNodeSocketType *st = RNA_struct_blender_type_get(type);
1720         if (!st)
1721                 return;
1722         
1723         RNA_struct_free_extension(type, &st->ext_socket);
1724
1725         nodeUnregisterSocketType(st);
1726
1727         RNA_struct_free(&BLENDER_RNA, type);
1728
1729         /* update while blender is running */
1730         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1731 }
1732
1733 static StructRNA *rna_NodeSocket_register(Main *bmain, ReportList *reports, void *data, const char *identifier,
1734                                           StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1735 {
1736         bNodeSocketType *st, dummyst;
1737         bNodeSocket dummysock;
1738         PointerRNA dummyptr;
1739         int have_function[2];
1740
1741         /* setup dummy socket & socket type to store static properties in */
1742         memset(&dummyst, 0, sizeof(bNodeSocketType));
1743         
1744         memset(&dummysock, 0, sizeof(bNodeSocket));
1745         dummysock.typeinfo = &dummyst;
1746         RNA_pointer_create(NULL, &RNA_NodeSocket, &dummysock, &dummyptr);
1747
1748         /* validate the python class */
1749         if (validate(&dummyptr, data, have_function) != 0)
1750                 return NULL;
1751         
1752         if (strlen(identifier) >= sizeof(dummyst.idname)) {
1753                 BKE_reportf(reports, RPT_ERROR, "Registering node socket class: '%s' is too long, maximum length is %d",
1754                             identifier, (int)sizeof(dummyst.idname));
1755                 return NULL;
1756         }
1757
1758         /* check if we have registered this socket type before */
1759         st = nodeSocketTypeFind(dummyst.idname);
1760         if (!st) {
1761                 /* create a new node socket type */
1762                 st = MEM_callocN(sizeof(bNodeSocketType), "node socket type");
1763                 memcpy(st, &dummyst, sizeof(dummyst));
1764                 
1765                 nodeRegisterSocketType(st);
1766         }
1767         
1768         /* if RNA type is already registered, unregister first */
1769         if (st->ext_socket.srna) {
1770                 StructRNA *srna = st->ext_socket.srna;
1771                 RNA_struct_free_extension(srna, &st->ext_socket);
1772                 RNA_struct_free(&BLENDER_RNA, srna);
1773         }
1774         st->ext_socket.srna = RNA_def_struct_ptr(&BLENDER_RNA, st->idname, &RNA_NodeSocket); 
1775         st->ext_socket.data = data;
1776         st->ext_socket.call = call;
1777         st->ext_socket.free = free;
1778         RNA_struct_blender_type_set(st->ext_socket.srna, st);
1779         
1780         /* XXX bad level call! needed to initialize the basic draw functions ... */
1781         ED_init_custom_node_socket_type(st);
1782
1783         st->draw = (have_function[0]) ? rna_NodeSocket_draw : NULL;
1784         st->draw_color = (have_function[1]) ? rna_NodeSocket_draw_color : NULL;
1785
1786         /* update while blender is running */
1787         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1788         
1789         return st->ext_socket.srna;
1790 }
1791
1792 static StructRNA *rna_NodeSocket_refine(PointerRNA *ptr)
1793 {
1794         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1795         
1796         if (sock->typeinfo->ext_socket.srna)
1797                 return sock->typeinfo->ext_socket.srna;
1798         else
1799                 return &RNA_NodeSocket;
1800 }
1801
1802 static char *rna_NodeSocket_path(PointerRNA *ptr)
1803 {
1804         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1805         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1806         bNode *node;
1807         int socketindex;
1808         char name_esc[sizeof(node->name) * 2];
1809         
1810         if (!nodeFindNode(ntree, sock, &node, &socketindex))
1811                 return NULL;
1812         
1813         BLI_strescape(name_esc, node->name, sizeof(name_esc));
1814
1815         if (sock->in_out == SOCK_IN) {
1816                 return BLI_sprintfN("nodes[\"%s\"].inputs[%d]", name_esc, socketindex);
1817         }
1818         else {
1819                 return BLI_sprintfN("nodes[\"%s\"].outputs[%d]", name_esc, socketindex);
1820         }
1821 }
1822
1823 static IDProperty *rna_NodeSocket_idprops(PointerRNA *ptr, bool create)
1824 {
1825         bNodeSocket *sock = ptr->data;
1826         
1827         if (create && !sock->prop) {
1828                 IDPropertyTemplate val = {0};
1829                 sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocket ID properties");
1830         }
1831         
1832         return sock->prop;
1833 }
1834
1835 static PointerRNA rna_NodeSocket_node_get(PointerRNA *ptr)
1836 {
1837         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1838         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1839         bNode *node;
1840         PointerRNA r_ptr;
1841         
1842         nodeFindNode(ntree, sock, &node, NULL);
1843         
1844         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &r_ptr);
1845         return r_ptr;
1846 }
1847
1848 static void rna_NodeSocket_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
1849 {
1850         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1851         ED_node_tag_update_nodetree(bmain, ntree);
1852 }
1853
1854 static void rna_NodeSocket_link_limit_set(PointerRNA *ptr, int value)
1855 {
1856         bNodeSocket *sock = ptr->data;
1857         sock->limit = (value == 0 ? 0xFFF : value);
1858 }
1859
1860 static void rna_NodeSocket_hide_set(PointerRNA *ptr, int value)
1861 {
1862         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1863         
1864         /* don't hide linked sockets */
1865         if (sock->flag & SOCK_IN_USE)
1866                 return;
1867         
1868         if (value)
1869                 sock->flag |= SOCK_HIDDEN;
1870         else
1871                 sock->flag &= ~SOCK_HIDDEN;
1872 }
1873
1874
1875 static void rna_NodeSocketInterface_draw(bContext *C, struct uiLayout *layout, PointerRNA *ptr)
1876 {
1877         extern FunctionRNA rna_NodeSocketInterface_draw_func;
1878
1879         bNodeSocket *stemp = (bNodeSocket *)ptr->data;
1880         ParameterList list;
1881         FunctionRNA *func;
1882
1883         if (!stemp->typeinfo)
1884                 return;
1885
1886         func = &rna_NodeSocketInterface_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
1887
1888         RNA_parameter_list_create(&list, ptr, func);
1889         RNA_parameter_set_lookup(&list, "context", &C);
1890         RNA_parameter_set_lookup(&list, "layout", &layout);
1891         stemp->typeinfo->ext_interface.call(C, ptr, func, &list);
1892
1893         RNA_parameter_list_free(&list);
1894 }
1895
1896 static void rna_NodeSocketInterface_draw_color(bContext *C, PointerRNA *ptr, float *r_color)
1897 {
1898         extern FunctionRNA rna_NodeSocketInterface_draw_color_func;
1899
1900         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1901         ParameterList list;
1902         FunctionRNA *func;
1903         void *ret;
1904
1905         if (!sock->typeinfo)
1906                 return;
1907
1908         func = &rna_NodeSocketInterface_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
1909
1910         RNA_parameter_list_create(&list, ptr, func);
1911         RNA_parameter_set_lookup(&list, "context", &C);
1912         sock->typeinfo->ext_interface.call(C, ptr, func, &list);
1913
1914         RNA_parameter_get_lookup(&list, "color", &ret);
1915         copy_v4_v4(r_color, (float *)ret);
1916
1917         RNA_parameter_list_free(&list);
1918 }
1919
1920 static void rna_NodeSocketInterface_register_properties(bNodeTree *ntree, bNodeSocket *stemp, StructRNA *data_srna)
1921 {
1922         extern FunctionRNA rna_NodeSocketInterface_register_properties_func;
1923
1924         PointerRNA ptr;
1925         ParameterList list;
1926         FunctionRNA *func;
1927
1928         if (!stemp->typeinfo)
1929                 return;
1930
1931         RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
1932         func = &rna_NodeSocketInterface_register_properties_func; /* RNA_struct_find_function(&ptr, "register_properties"); */
1933
1934         RNA_parameter_list_create(&list, &ptr, func);
1935         RNA_parameter_set_lookup(&list, "data_rna_type", &data_srna);
1936         stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
1937
1938         RNA_parameter_list_free(&list);
1939 }
1940
1941 static void rna_NodeSocketInterface_init_socket(bNodeTree *ntree, bNodeSocket *stemp, bNode *node, bNodeSocket *sock, const char *data_path)
1942 {
1943         extern FunctionRNA rna_NodeSocketInterface_init_socket_func;
1944
1945         PointerRNA ptr, node_ptr, sock_ptr;
1946         ParameterList list;
1947         FunctionRNA *func;
1948
1949         if (!stemp->typeinfo)
1950                 return;
1951
1952         RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
1953         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
1954         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr);
1955         func = &rna_NodeSocketInterface_init_socket_func; /* RNA_struct_find_function(&ptr, "init_socket"); */
1956
1957         RNA_parameter_list_create(&list, &ptr, func);
1958         RNA_parameter_set_lookup(&list, "node", &node_ptr);
1959         RNA_parameter_set_lookup(&list, "socket", &sock_ptr);
1960         RNA_parameter_set_lookup(&list, "data_path", &data_path);
1961         stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
1962
1963         RNA_parameter_list_free(&list);
1964 }
1965
1966 static void rna_NodeSocketInterface_from_socket(bNodeTree *ntree, bNodeSocket *stemp, bNode *node, bNodeSocket *sock)
1967 {
1968         extern FunctionRNA rna_NodeSocketInterface_from_socket_func;
1969
1970         PointerRNA ptr, node_ptr, sock_ptr;
1971         ParameterList list;
1972         FunctionRNA *func;
1973
1974         if (!stemp->typeinfo)
1975                 return;
1976
1977         RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
1978         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
1979         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr);
1980         func = &rna_NodeSocketInterface_from_socket_func; /* RNA_struct_find_function(&ptr, "from_socket"); */
1981
1982         RNA_parameter_list_create(&list, &ptr, func);
1983         RNA_parameter_set_lookup(&list, "node", &node_ptr);
1984         RNA_parameter_set_lookup(&list, "socket", &sock_ptr);
1985         stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
1986
1987         RNA_parameter_list_free(&list);
1988 }
1989
1990 static void rna_NodeSocketInterface_unregister(Main *UNUSED(bmain), StructRNA *type)
1991 {
1992         bNodeSocketType *st = RNA_struct_blender_type_get(type);
1993         if (!st)
1994                 return;
1995         
1996         RNA_struct_free_extension(type, &st->ext_interface);
1997         
1998         RNA_struct_free(&BLENDER_RNA, type);
1999         
2000         /* update while blender is running */
2001         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2002 }
2003
2004 static StructRNA *rna_NodeSocketInterface_register(Main *bmain, ReportList *reports, void *data, const char *identifier,
2005                                                   StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
2006 {
2007         bNodeSocketType *st, dummyst;
2008         bNodeSocket dummysock;
2009         PointerRNA dummyptr;
2010         int have_function[5];
2011
2012         /* setup dummy socket & socket type to store static properties in */
2013         memset(&dummyst, 0, sizeof(bNodeSocketType));
2014         
2015         memset(&dummysock, 0, sizeof(bNodeSocket));
2016         dummysock.typeinfo = &dummyst;
2017         RNA_pointer_create(NULL, &RNA_NodeSocketInterface, &dummysock, &dummyptr);
2018
2019         /* validate the python class */
2020         if (validate(&dummyptr, data, have_function) != 0)
2021                 return NULL;
2022
2023         /* check if we have registered this socket type before */
2024         st = nodeSocketTypeFind(dummyst.idname);
2025         if (st) {
2026                 /* basic socket type registered by a socket class before. */
2027         }
2028         else {
2029                 /* create a new node socket type */
2030                 st = MEM_callocN(sizeof(bNodeSocketType), "node socket type");
2031                 memcpy(st, &dummyst, sizeof(dummyst));
2032                 
2033                 nodeRegisterSocketType(st);
2034         }
2035         
2036         /* if RNA type is already registered, unregister first */
2037         if (st->ext_interface.srna) {
2038                 StructRNA *srna = st->ext_interface.srna;
2039                 RNA_struct_free_extension(srna, &st->ext_interface);
2040                 RNA_struct_free(&BLENDER_RNA, srna);
2041         }
2042         st->ext_interface.srna = RNA_def_struct_ptr(&BLENDER_RNA, identifier, &RNA_NodeSocketInterface); 
2043         st->ext_interface.data = data;
2044         st->ext_interface.call = call;
2045         st->ext_interface.free = free;
2046         RNA_struct_blender_type_set(st->ext_interface.srna, st);
2047         
2048         st->interface_draw = (have_function[0]) ? rna_NodeSocketInterface_draw : NULL;
2049         st->interface_draw_color = (have_function[1]) ? rna_NodeSocketInterface_draw_color : NULL;
2050         st->interface_register_properties = (have_function[2]) ? rna_NodeSocketInterface_register_properties : NULL;
2051         st->interface_init_socket = (have_function[3]) ? rna_NodeSocketInterface_init_socket : NULL;
2052         st->interface_from_socket = (have_function[4]) ? rna_NodeSocketInterface_from_socket : NULL;
2053         
2054         /* update while blender is running */
2055         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2056         
2057         return st->ext_interface.srna;
2058 }
2059
2060 static StructRNA *rna_NodeSocketInterface_refine(PointerRNA *ptr)
2061 {
2062         bNodeSocket *sock = (bNodeSocket *)ptr->data;
2063         
2064         if (sock->typeinfo && sock->typeinfo->ext_interface.srna)
2065                 return sock->typeinfo->ext_interface.srna;
2066         else
2067                 return &RNA_NodeSocketInterface;
2068 }
2069
2070 static char *rna_NodeSocketInterface_path(PointerRNA *ptr)
2071 {
2072         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2073         bNodeSocket *sock = (bNodeSocket *)ptr->data;
2074         int socketindex;
2075         
2076         socketindex = BLI_findindex(&ntree->inputs, sock);
2077         if (socketindex != -1)
2078                 return BLI_sprintfN("inputs[%d]", socketindex);
2079         
2080         socketindex = BLI_findindex(&ntree->outputs, sock);
2081         if (socketindex != -1)
2082                 return BLI_sprintfN("outputs[%d]", socketindex);
2083         
2084         return NULL;
2085 }
2086
2087 static IDProperty *rna_NodeSocketInterface_idprops(PointerRNA *ptr, bool create)
2088 {
2089         bNodeSocket *sock = ptr->data;
2090         
2091         if (create && !sock->prop) {
2092                 IDPropertyTemplate val = {0};
2093                 sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocketInterface ID properties");
2094         }
2095         
2096         return sock->prop;
2097 }
2098
2099 static void rna_NodeSocketInterface_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2100 {
2101         bNodeTree *ntree = ptr->id.data;
2102         bNodeSocket *stemp = ptr->data;
2103         
2104         if (!stemp->typeinfo)
2105                 return;
2106         
2107         ntree->update |= NTREE_UPDATE_GROUP;
2108         ntreeUpdateTree(G.main, ntree);
2109         
2110         ED_node_tag_update_nodetree(bmain, ntree);
2111 }
2112
2113
2114 /* ******** Standard Node Socket Base Types ******** */
2115
2116 static void rna_NodeSocketStandard_draw(ID *id, bNodeSocket *sock, struct bContext *C, struct uiLayout *layout, PointerRNA *nodeptr,
2117                                         const char *text)
2118 {
2119         PointerRNA ptr;
2120         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2121         sock->typeinfo->draw(C, layout, &ptr, nodeptr, text);
2122 }
2123
2124 static void rna_NodeSocketStandard_draw_color(ID *id, bNodeSocket *sock, struct bContext *C, PointerRNA *nodeptr, float *r_color)
2125 {
2126         PointerRNA ptr;
2127         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2128         sock->typeinfo->draw_color(C, &ptr, nodeptr, r_color);
2129 }
2130
2131 static void rna_NodeSocketInterfaceStandard_draw(ID *id, bNodeSocket *sock, struct bContext *C, struct uiLayout *layout)
2132 {
2133         PointerRNA ptr;
2134         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2135         sock->typeinfo->interface_draw(C, layout, &ptr);
2136 }
2137
2138 static void rna_NodeSocketInterfaceStandard_draw_color(ID *id, bNodeSocket *sock, struct bContext *C, float *r_color)
2139 {
2140         PointerRNA ptr;
2141         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2142         sock->typeinfo->interface_draw_color(C, &ptr, r_color);
2143 }
2144
2145 static void rna_NodeSocketStandard_float_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
2146 {
2147         bNodeSocket *sock = ptr->data;
2148         bNodeSocketValueFloat *dval = sock->default_value;
2149         int subtype = sock->typeinfo->subtype;
2150         
2151         *min = (subtype == PROP_UNSIGNED ? 0.0f : -FLT_MAX);
2152         *max = FLT_MAX;
2153         *softmin = dval->min;
2154         *softmax = dval->max;
2155 }
2156
2157 static void rna_NodeSocketStandard_int_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
2158 {
2159         bNodeSocket *sock = ptr->data;
2160         bNodeSocketValueInt *dval = sock->default_value;
2161         int subtype = sock->typeinfo->subtype;
2162         
2163         *min = (subtype == PROP_UNSIGNED ? 0 : INT_MIN);
2164         *max = INT_MAX;
2165         *softmin = dval->min;
2166         *softmax = dval->max;
2167 }
2168
2169 static void rna_NodeSocketStandard_vector_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
2170 {
2171         bNodeSocket *sock = ptr->data;
2172         bNodeSocketValueVector *dval = sock->default_value;
2173         
2174         *min = -FLT_MAX;
2175         *max = FLT_MAX;
2176         *softmin = dval->min;
2177         *softmax = dval->max;
2178 }
2179
2180 /* using a context update function here, to avoid searching the node if possible */
2181 static void rna_NodeSocketStandard_value_update(struct bContext *C, PointerRNA *ptr)
2182 {
2183         bNode *node;
2184         
2185         /* default update */
2186         rna_NodeSocket_update(CTX_data_main(C), CTX_data_scene(C), ptr);
2187         
2188         /* try to use node from context, faster */
2189         node = CTX_data_pointer_get(C, "node").data;
2190         if (!node) {
2191                 bNodeTree *ntree = ptr->id.data;
2192                 bNodeSocket *sock = ptr->data;
2193                 
2194                 /* fall back to searching node in the tree */
2195                 nodeFindNode(ntree, sock, &node, NULL);
2196         }
2197         
2198         if (node)
2199                 nodeSynchronizeID(node, true);
2200 }
2201
2202
2203 /* ******** Node Types ******** */
2204
2205 static void rna_NodeInternalSocketTemplate_name_get(PointerRNA *ptr, char *value)
2206 {
2207         bNodeSocketTemplate *stemp = ptr->data;
2208         strcpy(value, stemp->name);
2209 }
2210
2211 static int rna_NodeInternalSocketTemplate_name_length(PointerRNA *ptr)
2212 {
2213         bNodeSocketTemplate *stemp = ptr->data;
2214         return strlen(stemp->name);
2215 }
2216
2217 static void rna_NodeInternalSocketTemplate_identifier_get(PointerRNA *ptr, char *value)
2218 {
2219         bNodeSocketTemplate *stemp = ptr->data;
2220         strcpy(value, stemp->identifier);
2221 }
2222
2223 static int rna_NodeInternalSocketTemplate_identifier_length(PointerRNA *ptr)
2224 {
2225         bNodeSocketTemplate *stemp = ptr->data;
2226         return strlen(stemp->identifier);
2227 }
2228
2229 static int rna_NodeInternalSocketTemplate_type_get(PointerRNA *ptr)
2230 {
2231         bNodeSocketTemplate *stemp = ptr->data;
2232         return stemp->type;
2233 }
2234
2235 static PointerRNA rna_NodeInternal_input_template(StructRNA *srna, int index)
2236 {
2237         bNodeType *ntype = RNA_struct_blender_type_get(srna);
2238         if (ntype && ntype->inputs) {
2239                 bNodeSocketTemplate *stemp = ntype->inputs;
2240                 int i = 0;
2241                 while (i < index && stemp->type >= 0) {
2242                         ++i;
2243                         ++stemp;
2244                 }
2245                 if (i == index && stemp->type >= 0) {
2246                         PointerRNA ptr;
2247                         RNA_pointer_create(NULL, &RNA_NodeInternalSocketTemplate, stemp, &ptr);
2248                         return ptr;
2249                 }
2250         }
2251         return PointerRNA_NULL;
2252 }
2253
2254 static PointerRNA rna_NodeInternal_output_template(StructRNA *srna, int index)
2255 {
2256         bNodeType *ntype = RNA_struct_blender_type_get(srna);
2257         if (ntype && ntype->outputs) {
2258                 bNodeSocketTemplate *stemp = ntype->outputs;
2259                 int i = 0;
2260                 while (i < index && stemp->type >= 0) {
2261                         ++i;
2262                         ++stemp;
2263                 }
2264                 if (i == index && stemp->type >= 0) {
2265                         PointerRNA ptr;
2266                         RNA_pointer_create(NULL, &RNA_NodeInternalSocketTemplate, stemp, &ptr);
2267                         return ptr;
2268                 }
2269         }
2270         return PointerRNA_NULL;
2271 }
2272
2273 static int rna_NodeInternal_poll(StructRNA *srna, bNodeTree *ntree)
2274 {
2275         bNodeType *ntype = RNA_struct_blender_type_get(srna);
2276         return ntype && (!ntype->poll || ntype->poll(ntype, ntree));
2277 }
2278
2279 static int rna_NodeInternal_poll_instance(bNode *node, bNodeTree *ntree)
2280 {
2281         bNodeType *ntype = node->typeinfo;
2282         if (ntype->poll_instance) {
2283                 return ntype->poll_instance(node, ntree);
2284         }
2285         else {
2286                 /* fall back to basic poll function */
2287                 return !ntype->poll || ntype->poll(ntype, ntree);
2288         }
2289 }
2290
2291 static void rna_NodeInternal_update(ID *id, bNode *node)
2292 {
2293         bNodeTree *ntree = (bNodeTree *)id;
2294         if (node->typeinfo->updatefunc)
2295                 node->typeinfo->updatefunc(ntree, node);
2296 }
2297
2298 static void rna_NodeInternal_draw_buttons(ID *id, bNode *node, struct bContext *C, struct uiLayout *layout)
2299 {
2300         if (node->typeinfo->uifunc) {
2301                 PointerRNA ptr;
2302                 RNA_pointer_create(id, &RNA_Node, node, &ptr);
2303                 node->typeinfo->uifunc(layout, C, &ptr);
2304         }
2305 }
2306
2307 static void rna_NodeInternal_draw_buttons_ext(ID *id, bNode *node, struct bContext *C, struct uiLayout *layout)
2308 {
2309         if (node->typeinfo->uifuncbut) {
2310                 PointerRNA ptr;
2311                 RNA_pointer_create(id, &RNA_Node, node, &ptr);
2312                 node->typeinfo->uifuncbut(layout, C, &ptr);
2313         }
2314         else if (node->typeinfo->uifunc) {
2315                 PointerRNA ptr;
2316                 RNA_pointer_create(id, &RNA_Node, node, &ptr);
2317                 node->typeinfo->uifunc(layout, C, &ptr);
2318         }
2319 }
2320
2321 static StructRNA *rna_NodeCustomGroup_register(Main *bmain, ReportList *reports,
2322                                                void *data, const char *identifier,
2323                                                StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
2324 {
2325         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_NodeCustomGroup, data, identifier, validate, call, free);
2326         if (!nt)
2327                 return NULL;
2328         
2329         /* this updates the group node instance from the tree's interface */
2330         nt->verifyfunc = node_group_verify;
2331         
2332         nodeRegisterType(nt);
2333         
2334         /* update while blender is running */
2335         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2336         
2337         return nt->ext.srna;
2338 }
2339
2340 static void rna_CompositorNode_tag_need_exec(bNode *node)
2341 {
2342         node->need_exec = TRUE;
2343 }
2344
2345 static void rna_Node_tex_image_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2346 {
2347         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2348
2349         ED_node_tag_update_nodetree(bmain, ntree);
2350         WM_main_add_notifier(NC_IMAGE, NULL);
2351 }
2352
2353 static void rna_Node_material_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2354 {
2355         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2356         bNode *node = (bNode *)ptr->data;
2357
2358         if (node->id)
2359                 nodeSetActive(ntree, node);
2360
2361         ED_node_tag_update_nodetree(bmain, ntree);
2362 }
2363
2364 static void rna_NodeGroup_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2365 {
2366         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2367         bNode *node = (bNode *)ptr->data;
2368         
2369         if (node->id)
2370                 ntreeUpdateTree(bmain, (bNodeTree *)node->id);
2371         
2372         ED_node_tag_update_nodetree(bmain, ntree);
2373 }
2374
2375 static void rna_NodeGroup_node_tree_set(PointerRNA *ptr, const PointerRNA value)
2376 {
2377         bNodeTree *ntree = ptr->id.data;
2378         bNode *node = ptr->data;
2379         bNodeTree *ngroup = value.data;
2380         
2381         if (nodeGroupPoll(ntree, ngroup)) {
2382                 if (node->id)
2383                         id_us_min(node->id);
2384                 if (ngroup)
2385                         id_us_plus(&ngroup->id);
2386                 
2387                 node->id = &ngroup->id;
2388         }
2389 }
2390
2391 static int rna_NodeGroup_node_tree_poll(PointerRNA *ptr, const PointerRNA value)
2392 {
2393         bNodeTree *ntree = ptr->id.data;
2394         bNodeTree *ngroup = value.data;
2395         
2396         /* only allow node trees of the same type as the group node's tree */
2397         if (ngroup->type != ntree->type)
2398                 return false;
2399         
2400         return nodeGroupPoll(ntree, ngroup);
2401 }
2402
2403
2404 static StructRNA *rna_NodeGroup_interface_typef(PointerRNA *ptr)
2405 {
2406         bNode *node = ptr->data;
2407         bNodeTree *ngroup = (bNodeTree *)node->id;
2408
2409         if (ngroup) {
2410                 StructRNA *srna = ntreeInterfaceTypeGet(ngroup, TRUE);
2411                 if (srna)
2412                         return srna;
2413         }
2414         return &RNA_PropertyGroup;
2415 }
2416
2417 static StructRNA *rna_NodeGroupInputOutput_interface_typef(PointerRNA *ptr)
2418 {
2419         bNodeTree *ntree = ptr->id.data;
2420         
2421         if (ntree) {
2422                 StructRNA *srna = ntreeInterfaceTypeGet(ntree, TRUE);
2423                 if (srna)
2424                         return srna;
2425         }
2426         return &RNA_PropertyGroup;
2427 }
2428
2429 static void rna_distance_matte_t1_set(PointerRNA *ptr, float value)
2430 {
2431         bNode *node = (bNode *)ptr->data;
2432         NodeChroma *chroma = node->storage;
2433
2434         chroma->t1 = value;
2435 }
2436
2437 static void rna_distance_matte_t2_set(PointerRNA *ptr, float value)
2438 {
2439         bNode *node = (bNode *)ptr->data;
2440         NodeChroma *chroma = node->storage;
2441
2442         chroma->t2 = value;
2443 }
2444
2445 static void rna_difference_matte_t1_set(PointerRNA *ptr, float value)
2446 {
2447         bNode *node = (bNode *)ptr->data;
2448         NodeChroma *chroma = node->storage;
2449
2450         chroma->t1 = value;
2451 }
2452
2453 static void rna_difference_matte_t2_set(PointerRNA *ptr, float value)
2454 {
2455         bNode *node = (bNode *)ptr->data;
2456         NodeChroma *chroma = node->storage;
2457
2458         chroma->t2 = value;
2459 }
2460
2461 /* Button Set Funcs for Matte Nodes */
2462 static void rna_Matte_t1_set(PointerRNA *ptr, float value)
2463 {
2464         bNode *node = (bNode *)ptr->data;
2465         NodeChroma *chroma = node->storage;
2466         
2467         chroma->t1 = value;
2468         
2469         if (value < chroma->t2) 
2470                 chroma->t2 = value;
2471 }
2472
2473 static void rna_Matte_t2_set(PointerRNA *ptr, float value)
2474 {
2475         bNode *node = (bNode *)ptr->data;
2476         NodeChroma *chroma = node->storage;
2477         
2478         if (value > chroma->t1) 
2479                 value = chroma->t1;
2480         
2481         chroma->t2 = value;
2482 }
2483
2484 static void rna_Node_scene_set(PointerRNA *ptr, PointerRNA value)
2485 {
2486         bNode *node = (bNode *)ptr->data;
2487
2488         if (node->id) {
2489                 id_us_min(node->id);
2490                 node->id = NULL;
2491         }
2492
2493         node->id = value.data;
2494
2495         id_us_plus(node->id);
2496 }
2497
2498 static void rna_Node_image_layer_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2499 {
2500         bNode *node = (bNode *)ptr->data;
2501         Image *ima = (Image *)node->id;
2502         ImageUser *iuser = node->storage;
2503         
2504         BKE_image_multilayer_index(ima->rr, iuser);
2505         BKE_image_signal(ima, iuser, IMA_SIGNAL_SRC_CHANGE);
2506         
2507         rna_Node_update(bmain, scene, ptr);
2508 }
2509
2510 static EnumPropertyItem *renderresult_layers_add_enum(RenderLayer *rl)
2511 {
2512         EnumPropertyItem *item = NULL;
2513         EnumPropertyItem tmp = {0, "", 0, "", ""};
2514         int i = 0, totitem = 0;
2515         
2516         while (rl) {
2517                 tmp.identifier = rl->name;
2518                 /* little trick: using space char instead empty string makes the item selectable in the dropdown */
2519                 if (rl->name[0] == '\0')
2520                         tmp.name = " ";
2521                 else
2522                         tmp.name = rl->name;
2523                 tmp.value = i++;
2524                 RNA_enum_item_add(&item, &totitem, &tmp);
2525                 rl = rl->next;
2526         }
2527         
2528         RNA_enum_item_end(&item, &totitem);
2529
2530         return item;
2531 }
2532
2533 static EnumPropertyItem *rna_Node_image_layer_itemf(bContext *UNUSED(C), PointerRNA *ptr,
2534                                                     PropertyRNA *UNUSED(prop), int *free)
2535 {
2536         bNode *node = (bNode *)ptr->data;
2537         Image *ima = (Image *)node->id;
2538         EnumPropertyItem *item = NULL;
2539         RenderLayer *rl;
2540         
2541         if (!ima || !(ima->rr)) return NULL;
2542         
2543         rl = ima->rr->layers.first;
2544         item = renderresult_layers_add_enum(rl);
2545         
2546         *free = 1;
2547         
2548         return item;
2549 }
2550
2551 static EnumPropertyItem *rna_Node_scene_layer_itemf(bContext *UNUSED(C), PointerRNA *ptr,
2552                                                     PropertyRNA *UNUSED(prop), int *free)
2553 {
2554         bNode *node = (bNode *)ptr->data;
2555         Scene *sce = (Scene *)node->id;
2556         EnumPropertyItem *item = NULL;
2557         RenderLayer *rl;
2558         
2559         if (!sce) return NULL;
2560         
2561         rl = sce->r.layers.first;
2562         item = renderresult_layers_add_enum(rl);
2563         
2564         *free = 1;
2565         
2566         return item;
2567 }
2568
2569 static EnumPropertyItem *rna_Node_channel_itemf(bContext *UNUSED(C), PointerRNA *ptr,
2570                                                 PropertyRNA *UNUSED(prop), int *free)
2571 {
2572         bNode *node = (bNode *)ptr->data;
2573         EnumPropertyItem *item = NULL;
2574         EnumPropertyItem tmp = {0, "", 0, "", ""};
2575         int totitem = 0;
2576         
2577         switch (node->custom1) {
2578                 case CMP_NODE_CHANNEL_MATTE_CS_RGB:
2579                         tmp.identifier = "R"; tmp.name = "R"; tmp.value = 1;
2580                         RNA_enum_item_add(&item, &totitem, &tmp);
2581                         tmp.identifier = "G"; tmp.name = "G"; tmp.value = 2;
2582                         RNA_enum_item_add(&item, &totitem, &tmp);
2583                         tmp.identifier = "B"; tmp.name = "B"; tmp.value = 3;
2584                         RNA_enum_item_add(&item, &totitem, &tmp);
2585                         break;
2586                 case CMP_NODE_CHANNEL_MATTE_CS_HSV:
2587                         tmp.identifier = "H"; tmp.name = "H"; tmp.value = 1;
2588                         RNA_enum_item_add(&item, &totitem, &tmp);
2589                         tmp.identifier = "S"; tmp.name = "S"; tmp.value = 2;
2590                         RNA_enum_item_add(&item, &totitem, &tmp);
2591                         tmp.identifier = "V"; tmp.name = "V"; tmp.value = 3;
2592                         RNA_enum_item_add(&item, &totitem, &tmp);
2593                         break;
2594                 case CMP_NODE_CHANNEL_MATTE_CS_YUV:
2595                         tmp.identifier = "Y"; tmp.name = "Y"; tmp.value = 1;
2596                         RNA_enum_item_add(&item, &totitem, &tmp);
2597                         tmp.identifier = "G"; tmp.name = "U"; tmp.value = 2;
2598                         RNA_enum_item_add(&item, &totitem, &tmp);
2599                         tmp.identifier = "V"; tmp.name = "V"; tmp.value = 3;
2600                         RNA_enum_item_add(&item, &totitem, &tmp);
2601                         break;
2602                 case CMP_NODE_CHANNEL_MATTE_CS_YCC:
2603                         tmp.identifier = "Y"; tmp.name = "Y"; tmp.value = 1;
2604                         RNA_enum_item_add(&item, &totitem, &tmp);
2605                         tmp.identifier = "CB"; tmp.name = "Cr"; tmp.value = 2;
2606                         RNA_enum_item_add(&item, &totitem, &tmp);
2607                         tmp.identifier = "CR"; tmp.name = "Cb"; tmp.value = 3;
2608                         RNA_enum_item_add(&item, &totitem, &tmp);
2609                         break;
2610                 default:
2611                         break;
2612         }
2613
2614         RNA_enum_item_end(&item, &totitem);
2615         *free = 1;
2616         
2617         return item;
2618 }
2619
2620 static void rna_Image_Node_update_id(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
2621 {
2622         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2623         bNode *node = (bNode *)ptr->data;
2624
2625         node->update |= NODE_UPDATE_ID;
2626         nodeUpdate(ntree, node);        /* to update image node sockets */
2627 }
2628
2629 static void rna_Mapping_Node_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2630 {
2631         bNode *node = ptr->data;
2632         init_tex_mapping(node->storage);
2633         rna_Node_update(bmain, scene, ptr);
2634 }
2635
2636 static void rna_NodeOutputFile_slots_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
2637 {
2638         bNode *node = ptr->data;
2639         rna_iterator_listbase_begin(iter, &node->inputs, NULL);
2640 }
2641
2642 static PointerRNA rna_NodeOutputFile_slot_file_get(CollectionPropertyIterator *iter)
2643 {
2644         PointerRNA ptr;
2645         bNodeSocket *sock = rna_iterator_listbase_get(iter);
2646         RNA_pointer_create(iter->parent.id.data, &RNA_NodeOutputFileSlotFile, sock->storage, &ptr);
2647         return ptr;
2648 }
2649
2650 /* ******** Node Socket Types ******** */
2651
2652 static PointerRNA rna_NodeOutputFile_slot_layer_get(CollectionPropertyIterator *iter)
2653 {
2654         PointerRNA ptr;
2655         bNodeSocket *sock = rna_iterator_listbase_get(iter);
2656         RNA_pointer_create(iter->parent.id.data, &RNA_NodeOutputFileSlotLayer, sock->storage, &ptr);
2657         return ptr;
2658 }
2659
2660 static int rna_NodeOutputFileSocket_find_node(bNodeTree *ntree, NodeImageMultiFileSocket *data, bNode **nodep, bNodeSocket **sockp)
2661 {
2662         bNode *node;
2663         bNodeSocket *sock;
2664         
2665         for (node = ntree->nodes.first; node; node = node->next) {
2666                 for (sock = node->inputs.first; sock; sock = sock->next) {
2667                         NodeImageMultiFileSocket *sockdata = sock->storage;
2668                         if (sockdata == data) {
2669                                 *nodep = node;
2670                                 *sockp = sock;
2671                                 return 1;
2672                         }
2673                 }
2674         }
2675         
2676         *nodep = NULL;
2677         *sockp = NULL;
2678         return 0;
2679 }
2680
2681 static void rna_NodeOutputFileSlotFile_path_set(PointerRNA *ptr, const char *value)
2682 {
2683         bNodeTree *ntree = ptr->id.data;
2684         NodeImageMultiFileSocket *sockdata = ptr->data;
2685         bNode *node;
2686         bNodeSocket *sock;
2687         
2688         if (rna_NodeOutputFileSocket_find_node(ntree, sockdata, &node, &sock)) {
2689                 ntreeCompositOutputFileSetPath(node, sock, value);
2690         }
2691 }
2692
2693 static void rna_NodeOutputFileSlotLayer_name_set(PointerRNA *ptr, const char *value)
2694 {
2695         bNodeTree *ntree = ptr->id.data;
2696         NodeImageMultiFileSocket *sockdata = ptr->data;
2697         bNode *node;
2698         bNodeSocket *sock;
2699         
2700         if (rna_NodeOutputFileSocket_find_node(ntree, sockdata, &node, &sock)) {
2701                 ntreeCompositOutputFileSetLayer(node, sock, value);
2702         }
2703 }
2704
2705 static void rna_ShaderNodeScript_mode_set(PointerRNA *ptr, int value)
2706 {
2707         bNode *node = (bNode *)ptr->data;
2708         NodeShaderScript *nss = node->storage;
2709
2710         if (nss->mode != value) {
2711                 nss->mode = value;
2712                 nss->filepath[0] = '\0';
2713                 nss->flag &= ~NODE_SCRIPT_AUTO_UPDATE;
2714
2715                 /* replace text datablock by filepath */
2716                 if (node->id) {
2717                         Text *text = (Text *)node->id;
2718
2719                         if (value == NODE_SCRIPT_EXTERNAL && text->name) {
2720                                 BLI_strncpy(nss->filepath, text->name, sizeof(nss->filepath));
2721                                 BLI_path_rel(nss->filepath, G.main->name);
2722                         }
2723
2724                         id_us_min(node->id);
2725                         node->id = NULL;
2726                 }
2727
2728                 /* remove any bytecode */
2729                 if (nss->bytecode) {
2730                         MEM_freeN(nss->bytecode);
2731                         nss->bytecode = NULL;
2732                 }
2733
2734                 nss->bytecode_hash[0] = '\0';
2735         }
2736 }
2737
2738 static void rna_ShaderNodeScript_bytecode_get(PointerRNA *ptr, char *value)
2739 {
2740         bNode *node = (bNode *)ptr->data;
2741         NodeShaderScript *nss = node->storage;
2742
2743         strcpy(value, (nss->bytecode) ? nss->bytecode : "");
2744 }
2745
2746 static int rna_ShaderNodeScript_bytecode_length(PointerRNA *ptr)
2747 {
2748         bNode *node = (bNode *)ptr->data;
2749         NodeShaderScript *nss = node->storage;
2750
2751         return (nss->bytecode) ? strlen(nss->bytecode) : 0;
2752 }
2753
2754 static void rna_ShaderNodeScript_bytecode_set(PointerRNA *ptr, const char *value)
2755 {
2756         bNode *node = (bNode *)ptr->data;
2757         NodeShaderScript *nss = node->storage;
2758
2759         if (nss->bytecode)
2760                 MEM_freeN(nss->bytecode);
2761
2762         if (value && value[0])
2763                 nss->bytecode = BLI_strdup(value);
2764         else
2765                 nss->bytecode = NULL;
2766 }
2767
2768 static void rna_ShaderNodeScript_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2769 {
2770         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2771         bNode *node = (bNode *)ptr->data;
2772         RenderEngineType *engine_type = RE_engines_find(scene->r.engine);
2773
2774         if (engine_type && engine_type->update_script_node) {
2775                 /* auto update node */
2776                 RenderEngine *engine = RE_engine_create(engine_type);
2777                 engine_type->update_script_node(engine, ntree, node);
2778                 RE_engine_free(engine);
2779         }
2780
2781         ED_node_tag_update_nodetree(bmain, ntree);
2782 }
2783
2784 #else
2785
2786 static EnumPropertyItem prop_image_layer_items[] = {
2787         { 0, "PLACEHOLDER",          0, "Placeholder",          ""},
2788         {0, NULL, 0, NULL, NULL}
2789 };
2790
2791 static EnumPropertyItem prop_scene_layer_items[] = {
2792         { 0, "PLACEHOLDER",          0, "Placeholder",          ""},
2793         {0, NULL, 0, NULL, NULL}
2794 };
2795
2796 static EnumPropertyItem prop_tri_channel_items[] = {
2797         { 1, "R", 0, "R", ""},
2798         { 2, "G", 0, "G", ""},
2799         { 3, "B", 0, "B", ""},
2800         {0, NULL, 0, NULL, NULL}
2801 };
2802
2803 static EnumPropertyItem node_flip_items[] = {
2804         {0, "X",  0, "Flip X",     ""},
2805         {1, "Y",  0, "Flip Y",     ""},
2806         {2, "XY", 0, "Flip X & Y", ""},
2807         {0, NULL, 0, NULL, NULL}
2808 };
2809
2810 static EnumPropertyItem node_ycc_items[] = {
2811         { 0, "ITUBT601", 0, "ITU 601",  ""},
2812         { 1, "ITUBT709", 0, "ITU 709",  ""},
2813         { 2, "JFIF",     0, "Jpeg",     ""},
2814         {0, NULL, 0, NULL, NULL}
2815 };
2816
2817 static EnumPropertyItem node_glossy_items[] = {
2818         {SHD_GLOSSY_SHARP,    "SHARP",    0, "Sharp",    ""},
2819         {SHD_GLOSSY_BECKMANN, "BECKMANN", 0, "Beckmann", ""},
2820         {SHD_GLOSSY_GGX,      "GGX",      0, "GGX",      ""},
2821         {0, NULL, 0, NULL, NULL}
2822 };
2823
2824 static EnumPropertyItem node_toon_items[] = {
2825         {SHD_TOON_DIFFUSE,    "DIFFUSE",  0, "Diffuse", ""},
2826         {SHD_TOON_GLOSSY,     "GLOSSY",   0, "Glossy",  ""},
2827         {0, NULL, 0, NULL, NULL}
2828 };
2829
2830 static EnumPropertyItem node_script_mode_items[] = {
2831         {NODE_SCRIPT_INTERNAL, "INTERNAL", 0, "Internal", "Use internal text datablock"},
2832         {NODE_SCRIPT_EXTERNAL, "EXTERNAL", 0, "External", "Use external .osl or .oso file"},
2833         {0, NULL, 0, NULL, NULL}
2834 };
2835
2836 /* -- Common nodes ---------------------------------------------------------- */
2837
2838 static void def_group_input(StructRNA *srna)
2839 {
2840         PropertyRNA *prop;
2841         
2842         prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
2843         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroupInputOutput_interface_typef", NULL);
2844         RNA_def_property_struct_type(prop, "PropertyGroup");
2845         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2846         RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
2847 }
2848
2849 static void def_group_output(StructRNA *srna)
2850 {
2851         PropertyRNA *prop;
2852         
2853         prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
2854         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroupInputOutput_interface_typef", NULL);
2855         RNA_def_property_struct_type(prop, "PropertyGroup");
2856         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2857         RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
2858         
2859         prop = RNA_def_property(srna, "is_active_output", PROP_BOOLEAN, PROP_NONE);
2860         RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_DO_OUTPUT);
2861         RNA_def_property_ui_text(prop, "Active Output", "True if this node is used as the active group output");
2862         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2863 }
2864
2865 static void def_group(StructRNA *srna)
2866 {
2867         PropertyRNA *prop;
2868         
2869         prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
2870         RNA_def_property_pointer_sdna(prop, NULL, "id");
2871         RNA_def_property_struct_type(prop, "NodeTree");
2872         RNA_def_property_pointer_funcs(prop, NULL, "rna_NodeGroup_node_tree_set", NULL, "rna_NodeGroup_node_tree_poll");
2873         RNA_def_property_flag(prop, PROP_EDITABLE);
2874         RNA_def_property_ui_text(prop, "Node Tree", "");
2875         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeGroup_update");
2876
2877         prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
2878         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroup_interface_typef", NULL);
2879         RNA_def_property_struct_type(prop, "PropertyGroup");
2880         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2881         RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
2882 }
2883
2884 static void def_custom_group(BlenderRNA *brna)
2885 {
2886         StructRNA *srna;
2887         
2888         srna = RNA_def_struct(brna, "NodeCustomGroup", "Node");
2889         RNA_def_struct_ui_text(srna, "Custom Group", "Base node type for custom registered node group types");
2890         RNA_def_struct_sdna(srna, "bNode");
2891
2892         RNA_def_struct_register_funcs(srna, "rna_NodeCustomGroup_register", "rna_Node_unregister", NULL);
2893
2894         def_group(srna);
2895 }
2896
2897 static void def_frame(StructRNA *srna)
2898 {
2899         PropertyRNA *prop; 
2900         
2901         RNA_def_struct_sdna_from(srna, "NodeFrame", "storage");
2902         
2903         prop = RNA_def_property(srna, "shrink", PROP_BOOLEAN, PROP_NONE);
2904         RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_FRAME_SHRINK);
2905         RNA_def_property_ui_text(prop, "Shrink", "Shrink the frame to minimal bounding box");
2906         RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL);
2907
2908         prop = RNA_def_property(srna, "label_size", PROP_INT, PROP_NONE);
2909         RNA_def_property_int_sdna(prop, NULL, "label_size");
2910         RNA_def_property_range(prop, 8, 64);
2911         RNA_def_property_ui_text(prop, "Label Font Size", "Font size to use for displaying the label");
2912         RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL);
2913 }
2914
2915 static void def_math(StructRNA *srna)
2916 {
2917         PropertyRNA *prop;
2918         
2919         prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
2920         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2921         RNA_def_property_enum_items(prop, node_math_items);
2922         RNA_def_property_ui_text(prop, "Operation", "");
2923         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2924
2925         prop = RNA_def_property(srna, "use_clamp", PROP_BOOLEAN, PROP_NONE);
2926         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 1);
2927         RNA_def_property_ui_text(prop, "Clamp", "Clamp result of the node to 0..1 range");
2928         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2929 }
2930
2931 static void def_vector_math(StructRNA *srna)
2932 {
2933         PropertyRNA *prop;
2934         
2935         prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
2936         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2937         RNA_def_property_enum_items(prop, node_vec_math_items);
2938         RNA_def_property_ui_text(prop, "Operation", "");
2939         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2940 }
2941
2942 static void def_rgb_curve(StructRNA *srna)
2943 {
2944         PropertyRNA *prop;
2945         
2946         prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
2947         RNA_def_property_pointer_sdna(prop, NULL, "storage");
2948         RNA_def_property_struct_type(prop, "CurveMapping");
2949         RNA_def_property_ui_text(prop, "Mapping", "");
2950         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2951 }
2952
2953 static void def_vector_curve(StructRNA *srna)
2954 {
2955         PropertyRNA *prop;
2956         
2957         prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
2958         RNA_def_property_pointer_sdna(prop, NULL, "storage");
2959         RNA_def_property_struct_type(prop, "CurveMapping");
2960         RNA_def_property_ui_text(prop, "Mapping", "");
2961         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2962 }
2963
2964 static void def_time(StructRNA *srna)
2965 {
2966         PropertyRNA *prop;
2967         
2968         prop = RNA_def_property(srna, "curve", PROP_POINTER, PROP_NONE);
2969         RNA_def_property_pointer_sdna(prop, NULL, "storage");
2970         RNA_def_property_struct_type(prop, "CurveMapping");
2971         RNA_def_property_ui_text(prop, "Curve", "");
2972         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2973         
2974         prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_NONE);
2975         RNA_def_property_int_sdna(prop, NULL, "custom1");
2976         RNA_def_property_ui_text(prop, "Start Frame", "");
2977         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2978         
2979         prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_NONE);
2980         RNA_def_property_int_sdna(prop, NULL, "custom2");
2981         RNA_def_property_ui_text(prop, "End Frame", "");
2982         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2983 }
2984
2985 static void def_colorramp(StructRNA *srna)
2986 {
2987         PropertyRNA *prop;
2988         
2989         prop = RNA_def_property(srna, "color_ramp", PROP_POINTER, PROP_NONE);
2990         RNA_def_property_pointer_sdna(prop, NULL, "storage");
2991         RNA_def_property_struct_type(prop, "ColorRamp");
2992         RNA_def_property_ui_text(prop, "Color Ramp", "");
2993         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2994 }
2995
2996 static void def_mix_rgb(StructRNA *srna)
2997 {
2998         PropertyRNA *prop;
2999         
3000         prop = RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
3001         RNA_def_property_enum_sdna(prop, NULL, "custom1");
3002         RNA_def_property_enum_items(prop, ramp_blend_items);
3003         RNA_def_property_ui_text(prop, "Blend Type", "");
3004         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3005         
3006         prop = RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
3007         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 1);
3008         RNA_def_property_ui_text(prop, "Alpha", "Include alpha of second input in this operation");
3009         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3010
3011         prop = RNA_def_property(srna, "use_clamp", PROP_BOOLEAN, PROP_NONE);
3012         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 2);
3013         RNA_def_property_ui_text(prop, "Clamp", "Clamp result of the node to 0..1 range");
3014         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3015 }
3016
3017 static void def_texture(StructRNA *srna)
3018 {
3019         PropertyRNA *prop;
3020         
3021         prop = RNA_def_property(srna, "texture", PROP_POINTER, PROP_NONE);
3022         RNA_def_property_pointer_sdna(prop, NULL, "id");
3023         RNA_def_property_struct_type(prop, "Texture");
3024         RNA_def_property_flag(prop, PROP_EDITABLE);
3025         RNA_def_property_ui_text(prop, "Texture", "");
3026         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3027         
3028         prop = RNA_def_property(srna, "node_output", PROP_INT, PROP_NONE);
3029         RNA_def_property_int_sdna(prop, NULL, "custom1");
3030         RNA_def_property_ui_text(prop, "Node Output", "For node-based textures, which output node to use");
3031         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3032 }
3033
3034
3035 /* -- Shader Nodes ---------------------------------------------------------- */
3036
3037 static void def_sh_material(StructRNA *srna)
3038 {
3039         PropertyRNA *prop;
3040
3041         prop = RNA_def_property(srna, "material", PROP_POINTER, PROP_NONE);
3042         RNA_def_property_pointer_sdna(prop, NULL, "id");
3043         RNA_def_property_struct_type(prop, "Material");
3044         RNA_def_property_flag(prop, PROP_EDITABLE);
3045         RNA_def_property_ui_text(prop, "Material", "");
3046         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_material_update");
3047
3048         prop = RNA_def_property(srna, "use_diffuse", PROP_BOOLEAN, PROP_NONE);
3049         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_DIFF);
3050         RNA_def_property_ui_text(prop, "Diffuse", "Material Node outputs Diffuse");
3051         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3052
3053         prop = RNA_def_property(srna, "use_specular", PROP_BOOLEAN, PROP_NONE);
3054         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_SPEC);
3055         RNA_def_property_ui_text(prop, "Specular", "Material Node outputs Specular");
3056         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3057         
3058         prop = RNA_def_property(srna, "invert_normal", PROP_BOOLEAN, PROP_NONE);
3059         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_NEG);
3060         RNA_def_property_ui_text(prop, "Invert Normal", "Material Node uses inverted normal");
3061         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3062 }
3063
3064 static void def_sh_mapping(StructRNA *srna)
3065 {
3066         PropertyRNA *prop;
3067         
3068         RNA_def_struct_sdna_from(srna, "TexMapping", "storage");
3069
3070         prop = RNA_def_property(srna, "translation", PROP_FLOAT, PROP_TRANSLATION);
3071         RNA_def_property_float_sdna(prop, NULL, "loc");
3072         RNA_def_property_ui_text(prop, "Location", "");
3073         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3074         
3075         /* Not PROP_XYZ, this is now in radians, no more degrees */
3076         prop = RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_EULER);
3077         RNA_def_property_float_sdna(prop, NULL, "rot");
3078         RNA_def_property_ui_text(prop, "Rotation", "");
3079         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3080         
3081         prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
3082         RNA_def_property_float_sdna(prop, NULL, "size");
3083         RNA_def_property_ui_text(prop, "Scale", "");
3084         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3085         
3086         prop = RNA_def_property(srna, "min", PROP_FLOAT, PROP_XYZ);
3087         RNA_def_property_float_sdna(prop, NULL, "min");
3088         RNA_def_property_ui_text(prop, "Minimum", "Minimum value for clipping");
3089         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3090         
3091         prop = RNA_def_property(srna, "max", PROP_FLOAT, PROP_XYZ);
3092         RNA_def_property_float_sdna(prop, NULL, "max");
3093         RNA_def_property_ui_text(prop, "Maximum", "Maximum value for clipping");
3094         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3095         
3096         prop = RNA_def_property(srna, "use_min", PROP_BOOLEAN, PROP_NONE);
3097         RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MIN);
3098         RNA_def_property_ui_text(prop, "Has Minimum", "Whether to use minimum clipping value");
3099         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3100         
3101         prop = RNA_def_property(srna, "use_max", PROP_BOOLEAN, PROP_NONE);
3102         RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MAX);
3103         RNA_def_property_ui_text(prop, "Has Maximum", "Whether to use maximum clipping value");
3104         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3105 }
3106
3107 static void def_sh_geometry(StructRNA *srna)
3108 {
3109         PropertyRNA *prop;
3110         
3111         RNA_def_struct_sdna_from(srna, "NodeGeometry", "storage");
3112         
3113         prop = RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE);
3114         RNA_def_property_string_sdna(prop, NULL, "uvname");
3115         RNA_def_property_ui_text(prop, "UV Map", "");
3116         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3117         
3118         prop = RNA_def_property(srna, "color_layer", PROP_STRING, PROP_NONE);
3119         RNA_def_property_string_sdna(prop, NULL, "colname");
3120         RNA_def_property_ui_text(prop, "Vertex Color Layer", "");
3121         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3122 }
3123
3124 static void def_sh_attribute(StructRNA *srna)
3125 {
3126         PropertyRNA *prop;
3127         
3128         RNA_def_struct_sdna_from(srna, "NodeShaderAttribute", "storage");
3129         
3130         prop = RNA_def_property(srna, "attribute_name", PROP_STRING, PROP_NONE);
3131         RNA_def_property_string_sdna(prop, NULL, "name");
3132         RNA_def_property_ui_text(prop, "Attribute Name", "");
3133         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3134 }
3135
3136 static void def_sh_tex(StructRNA *srna)
3137 {
3138         PropertyRNA *prop;
3139
3140         prop = RNA_def_property(srna, "texture_mapping", PROP_POINTER, PROP_NONE);
3141         RNA_def_property_pointer_sdna(prop, NULL, "base.tex_mapping");
3142         RNA_def_property_flag(prop, PROP_NEVER_NULL);
3143         RNA_def_property_ui_text(prop, "Texture Mapping", "Texture coordinate mapping settings");
3144
3145         prop = RNA_def_property(srna, "color_mapping", PROP_POINTER, PROP_NONE);
3146         RNA_def_property_pointer_sdna(prop, NULL, "base.color_mapping");
3147         RNA_def_property_flag(prop, PROP_NEVER_NULL);
3148         RNA_def_property_ui_text(prop, "Color Mapping", "Color mapping settings");
3149 }
3150
3151 static void def_sh_tex_sky(StructRNA *srna)
3152 {
3153         PropertyRNA *prop;
3154         
3155         RNA_def_struct_sdna_from(srna, "NodeTexSky", "storage");
3156         def_sh_tex(srna);
3157         
3158         prop = RNA_def_property(srna, "sun_direction", PROP_FLOAT, PROP_DIRECTION);
3159         RNA_def_property_ui_text(prop, "Sun Direction", "Direction from where the sun is shining");
3160         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3161         
3162         prop = RNA_def_property(srna, "turbidity", PROP_FLOAT, PROP_NONE);
3163         RNA_def_property_range(prop, 1.0f, 30.0f);
3164         RNA_def_property_ui_text(prop, "Turbidity", "Atmospheric turbidity");
3165         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3166 }
3167
3168 static void def_sh_tex_environment(StructRNA *srna)
3169 {
3170         static const EnumPropertyItem prop_color_space_items[] = {
3171                 {SHD_COLORSPACE_COLOR, "COLOR", 0, "Color",
3172                                        "Image contains color data, and will be converted to linear color for rendering"},
3173                 {SHD_COLORSPACE_NONE, "NONE", 0, "Non-Color Data",
3174                                       "Image contains non-color data, for example a displacement or normal map, "
3175                                       "and will not be converted"},
3176                 {0, NULL, 0, NULL, NULL}
3177         };
3178
3179         static const EnumPropertyItem prop_projection_items[] = {
3180                 {SHD_PROJ_EQUIRECTANGULAR, "EQUIRECTANGULAR", 0, "Equirectangular",
3181                                            "Equirectangular or latitude-longitude projection"},
3182                 {SHD_PROJ_MIRROR_BALL, "MIRROR_BALL", 0, "Mirror Ball",
3183                                        "Projection from an orthographic photo of a mirror ball"},
3184                 {0, NULL, 0, NULL, NULL}
3185         };
3186         
3187         PropertyRNA *prop;
3188
3189         prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
3190         RNA_def_property_pointer_sdna(prop, NULL, "id");
3191         RNA_def_property_struct_type(prop, "Image");
3192         RNA_def_property_flag(prop, PROP_EDITABLE);
3193         RNA_def_property_ui_text(prop, "Image", "");
3194         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_tex_image_update");
3195
3196         RNA_def_struct_sdna_from(srna, "NodeTexEnvironment", "storage");
3197         def_sh_tex(srna);
3198
3199         prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
3200         RNA_def_property_enum_items(prop, prop_color_space_items);
3201         RNA_def_property_ui_text(prop, "Color Space", "Image file color space");
3202         RNA_def_property_update(prop, 0, "rna_Node_update");
3203
3204         prop = RNA_def_property(srna, "projection", PROP_ENUM, PROP_NONE);
3205         RNA_def_property_enum_items(prop, prop_projection_items);
3206         RNA_def_property_ui_text(prop, "Projection", "Projection of the input image");
3207         RNA_def_property_update(prop, 0, "rna_Node_update");
3208
3209         prop = RNA_def_property(srna, "image_user", PROP_POINTER, PROP_NONE);
3210         RNA_def_property_flag(prop, PROP_NEVER_NULL);
3211         RNA_def_property_pointer_sdna(prop, NULL, "iuser");
3212         RNA_def_property_ui_text(prop, "Image User",
3213                                  "Parameters defining which layer, pass and frame of the image is displayed");
3214         RNA_def_property_update(prop, 0, "rna_Node_update");
3215 }
3216
3217 static void def_sh_tex_image(StructRNA *srna)
3218 {
3219         static const EnumPropertyItem prop_color_space_items[] = {
3220                 {SHD_COLORSPACE_COLOR, "COLOR", 0, "Color",
3221                                        "Image contains color data, and will be converted to linear color for rendering"},
3222                 {SHD_COLORSPACE_NONE, "NONE", 0, "Non-Color Data",
3223                                       "Image contains non-color data, for example a displacement or normal map, "
3224                                       "and will not be converted"},
3225                 {0, NULL, 0, NULL, NULL}
3226         };
3227
3228         static const EnumPropertyItem prop_projection_items[] = {
3229                 {SHD_PROJ_FLAT, "FLAT", 0, "Flat",
3230                                 "Image is projected flat using the X and Y coordinates of the texture vector"},
3231                 {SHD_PROJ_BOX,  "BOX", 0, "Box",
3232                                 "Image is projected using different components for each side of the object space bounding box"},
3233                 {0, NULL, 0, NULL, NULL}
3234         };
3235
3236
3237         PropertyRNA *prop;
3238
3239         prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
3240         RNA_def_property_pointer_sdna(prop, NULL, "id");
3241         RNA_def_property_struct_type(prop, "Image");
3242         RNA_def_property_flag(prop, PROP_EDITABLE);
3243         RNA_def_property_ui_text(prop, "Image", "");
3244         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_tex_image_update");
3245
3246         RNA_def_struct_sdna_from(srna, "NodeTexImage", "storage");
3247         def_sh_tex(srna);
3248
3249         prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
3250         RNA_def_property_enum_items(prop, prop_color_space_items);
3251         RNA_def_property_ui_text(prop, "Color Space", "Image file color space");
3252         RNA_def_property_update(prop, 0, "rna_Node_update");
3253
3254         prop = RNA_def_property(srna, "projection", PROP_ENUM, PROP_NONE);
3255         RNA_def_property_enum_items(prop, prop_projection_items);
3256         RNA_def_property_ui_text(prop, "Projection", "Method to project 2D image on object with a 3D texture vector");
3257         RNA_def_property_update(prop, 0, "rna_Node_update");
3258
3259         prop = RNA_def_property(srna, "projection_blend", PROP_FLOAT, PROP_FACTOR);
3260         RNA_def_property_ui_text(prop, "Projection Blend", "For box projection, amount of blend to use between sides");
3261         RNA_def_property_update(prop, 0, "rna_Node_update");
3262
3263         prop = RNA_def_property(srna, "image_user", PROP_POINTER, PROP_NONE);
3264         RNA_def_property_flag(prop, PROP_NEVER_NULL);
3265         RNA_def_property_pointer_sdna(prop, NULL, "iuser");
3266         RNA_def_property_ui_text(prop, "Image User",
3267                                  "Parameters defining which layer, pass and frame of the image is displayed");
3268         RNA_def_property_update(prop, 0, "rna_Node_update");
3269 }
3270
3271 static void def_sh_tex_gradient(StructRNA *srna)
3272 {
3273         static EnumPropertyItem prop_gradient_type[] = {
3274                 {SHD_BLEND_LINEAR, "LINEAR", 0, "Linear", "Create a linear progression"},
3275                 {SHD_BLEND_QUADRATIC, "QUADRATIC", 0, "Quadratic", "Create a quadratic progression"},
3276                 {SHD_BLEND_EASING, "EASING", 0, "Easing", "Create a progression easing from one step to the next"},
3277                 {SHD_BLEND_DIAGONAL, "DIAGONAL", 0, "Diagonal", "Create a diagonal progression"},
3278                 {SHD_BLEND_SPHERICAL, "SPHERICAL", 0, "Spherical", "Create a spherical progression"},
3279                 {SHD_BLEND_QUADRATIC_SPHERE, "QUADRATIC_SPHERE", 0, "Quadratic sphere",
3280                                              "Create a quadratic progression in the shape of a sphere"},
3281                 {SHD_BLEND_RADIAL, "RADIAL", 0, "Radial", "Create a radial progression"},
3282                 {0, NULL, 0, NULL, NULL}
3283         };
3284
3285         PropertyRNA *prop;
3286         
3287         RNA_def_struct_sdna_from(srna, "NodeTexGradient", "storage");
3288         def_sh_tex(srna);
3289
3290         prop = RNA_def_property(srna, "gradient_type", PROP_ENUM, PROP_NONE);
3291         RNA_def_property_enum_items(prop, prop_gradient_type);
3292         RNA_def_property_ui_text(prop, "Gradient Type", "Style of the color blending");
3293         RNA_def_property_update(prop, 0, "rna_Node_update");
3294 }
3295
3296 static void def_sh_tex_noise(StructRNA *srna)
3297 {
3298         RNA_def_struct_sdna_from(srna, "NodeTexNoise", "storage");
3299         def_sh_tex(srna);
3300 }
3301
3302 static void def_sh_tex_checker(StructRNA *srna)
3303 {
3304         RNA_def_struct_sdna_from(srna, "NodeTexChecker", "storage");
3305         def_sh_tex(srna);
3306 }
3307
3308 static void def_sh_tex_brick(StructRNA *srna)
3309 {
3310         PropertyRNA *prop;
3311         
3312         RNA_def_struct_sdna_from(srna, "NodeTexBrick", "storage");
3313         def_sh_tex(srna);
3314         
3315         prop = RNA_def_property(srna, "offset_frequency", PROP_INT, PROP_NONE);
3316         RNA_def_property_int_sdna(prop, NULL, "offset_freq");
3317         RNA_def_property_int_default(prop, 2);
3318         RNA_def_property_range(prop, 1, 99);
3319         RNA_def_property_ui_text(prop, "Offset Frequency", "");
3320         RNA_def_property_update(prop, 0, "rna_Node_update");
3321         
3322         prop = RNA_def_property(srna, "squash_frequency", PROP_INT, PROP_NONE);
3323         RNA_def_property_int_sdna(prop, NULL, "squash_freq");
3324         RNA_def_property_int_default(prop, 2);
3325         RNA_def_property_range(prop, 1, 99);
3326         RNA_def_property_ui_text(prop, "Squash Frequency", "");
3327         RNA_def_property_update(prop, 0, "rna_Node_update");
3328         
3329         prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
3330         RNA_def_property_float_sdna(prop, NULL, "offset");
3331         RNA_def_property_float_default(prop, 0.5f);
3332         RNA_def_property_range(prop, 0.0f, 1.0f);
3333         RNA_def_property_ui_text(prop, "Offset Amount", "");
3334         RNA_def_property_update(prop, 0, "rna_Node_update");
3335         
3336         prop = RNA_def_property(srna, "squash", PROP_FLOAT, PROP_NONE);
3337         RNA_def_property_float_sdna(prop, NULL, "squash");
3338         RNA_def_property_float_default(prop, 1.0f);
3339         RNA_def_property_range(prop, 0.0f, 99.0f);
3340         RNA_def_property_ui_text(prop, "Squash Amount", "");
3341         RNA_def_property_update(prop, 0, "rna_Node_update");
3342         
3343 }
3344
3345 static void def_sh_tex_magic(StructRNA *srna)
3346 {
3347         PropertyRNA *prop;
3348         
3349         RNA_def_struct_sdna_from(srna, "NodeTexMagic", "storage");
3350         def_sh_tex(srna);
3351
3352         prop = RNA_def_property(srna, "turbulence_depth", PROP_INT, PROP_NONE);
3353         RNA_def_property_int_sdna(prop, NULL, "depth");
3354         RNA_def_property_range(prop, 0, 10);
3355         RNA_def_property_ui_text(prop, "Depth", "Level of detail in the added turbulent noise");
3356         RNA_def_property_update(prop, 0, "rna_Node_update");
3357 }
3358
3359 static void def_sh_tex_musgrave(StructRNA *srna)
3360 {
3361         static EnumPropertyItem prop_musgrave_type[] = {
3362                 {SHD_MUSGRAVE_MULTIFRACTAL, "MULTIFRACTAL", 0, "Multifractal", ""},
3363                 {SHD_MUSGRAVE_RIDGED_MULTIFRACTAL, "RIDGED_MULTIFRACTAL", 0, "Ridged Multifractal", ""},
3364                 {SHD_MUSGRAVE_HYBRID_MULTIFRACTAL, "HYBRID_MULTIFRACTAL", 0, "Hybrid Multifractal", ""},
3365                 {SHD_MUSGRAVE_FBM, "FBM", 0, "fBM", ""},
3366                 {SHD_MUSGRAVE_HETERO_TERRAIN, "HETERO_TERRAIN", 0, "Hetero Terrain", ""},
3367                 {0, NULL, 0, NULL, NULL}
3368         };
3369
3370         PropertyRNA *prop;
3371         
3372         RNA_def_struct_sdna_from(srna, "NodeTexMusgrave", "storage");
3373         def_sh_tex(srna);
3374
3375         prop = RNA_def_property(srna, "musgrave_type", PROP_ENUM, PROP_NONE);
3376         RNA_def_property_enum_sdna(prop, NULL, "musgrave_type");
3377         RNA_def_property_enum_items(prop, prop_musgrave_type);
3378         RNA_def_property_ui_text(prop, "Type", "");
3379         RNA_def_property_update(prop, 0, "rna_Node_update");
3380 }
3381
3382 static void def_sh_tex_voronoi(StructRNA *srna)
3383 {
3384         static EnumPropertyItem prop_coloring_items[] = {
3385                 {SHD_VORONOI_INTENSITY, "INTENSITY", 0, "Intensity", "Only calculate intensity"},
3386                 {SHD_VORONOI_CELLS, "CELLS", 0, "Cells", "Color cells by position"},
3387                 {0, NULL, 0, NULL, NULL}
3388         };
3389
3390         PropertyRNA *prop;
3391         
3392         RNA_def_struct_sdna_from(srna, "NodeTexVoronoi", "storage");
3393         def_sh_tex(srna);
3394
3395         prop = RNA_def_property(srna, "coloring", PROP_ENUM, PROP_NONE);
3396         RNA_def_property_enum_sdna(prop, NULL, "coloring");
3397         RNA_def_property_enum_items(prop, prop_coloring_items);
3398         RNA_def_property_ui_text(prop, "Coloring", "");
3399         RNA_def_property_u