style cleanup
[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
30 #include "BLI_listbase.h"
31 #include "BLI_math.h"
32 #include "BLI_string.h"
33 #include "BLI_utildefines.h"
34
35 #include "DNA_material_types.h"
36 #include "DNA_mesh_types.h"
37 #include "DNA_node_types.h"
38 #include "DNA_object_types.h"
39 #include "DNA_scene_types.h"
40 #include "DNA_text_types.h"
41 #include "DNA_texture_types.h"
42
43 #include "BKE_animsys.h"
44 #include "BKE_main.h"
45 #include "BKE_node.h"
46 #include "BKE_image.h"
47 #include "BKE_texture.h"
48 #include "BKE_idprop.h"
49
50 #include "RNA_access.h"
51 #include "RNA_define.h"
52 #include "RNA_enum_types.h"
53
54 #include "rna_internal.h"
55 #include "rna_internal_types.h"
56
57 #include "IMB_imbuf.h"
58 #include "IMB_imbuf_types.h"
59
60 #include "WM_types.h"
61
62 #include "MEM_guardedalloc.h"
63
64 EnumPropertyItem nodetree_type_items[] = {
65         {NTREE_SHADER,      "SHADER",       ICON_MATERIAL,      "Shader",       "Shader nodes"},
66         {NTREE_TEXTURE,     "TEXTURE",      ICON_TEXTURE,       "Texture",      "Texture nodes"},
67         {NTREE_COMPOSIT,    "COMPOSITING",  ICON_RENDERLAYERS,  "Compositing",  "Compositing nodes"},
68         {0, NULL, 0, NULL, NULL}
69 };
70
71 EnumPropertyItem node_quality_items[] = {
72         {NTREE_QUALITY_HIGH,   "HIGH",     0,    "High",     "High quality"},
73         {NTREE_QUALITY_MEDIUM, "MEDIUM",   0,    "Medium",   "Medium quality"},
74         {NTREE_QUALITY_LOW,    "LOW",      0,    "Low",      "Low quality"},
75         {0, NULL, 0, NULL, NULL}
76 };
77
78 EnumPropertyItem node_chunksize_items[] = {
79         {NTREE_CHUNCKSIZE_32,   "32",     0,    "32x32",     "Chunksize of 32x32"},
80         {NTREE_CHUNCKSIZE_64,   "64",     0,    "64x64",     "Chunksize of 64x64"},
81         {NTREE_CHUNCKSIZE_128,  "128",    0,    "128x128",   "Chunksize of 128x128"},
82         {NTREE_CHUNCKSIZE_256,  "256",    0,    "256x256",   "Chunksize of 256x256"},
83         {NTREE_CHUNCKSIZE_512,  "512",    0,    "512x512",   "Chunksize of 512x512"},
84         {NTREE_CHUNCKSIZE_1024, "1024",   0,    "1024x1024", "Chunksize of 1024x1024"},
85         {0, NULL, 0, NULL, NULL}
86 };
87
88 EnumPropertyItem node_socket_type_items[] = {
89         {SOCK_FLOAT,   "VALUE",     0,    "Value",     ""},
90         {SOCK_VECTOR,  "VECTOR",    0,    "Vector",    ""},
91         {SOCK_RGBA,    "RGBA",      0,    "RGBA",      ""},
92         {SOCK_SHADER,  "SHADER",    0,    "Shader",    ""},
93         {SOCK_BOOLEAN, "BOOLEAN",   0,    "Boolean",   ""},
94         {SOCK_MESH,    "MESH",      0,    "Mesh",      ""},
95         {SOCK_INT,     "INT",       0,    "Int",       ""},
96         {SOCK_STRING,  "STRING",    0,    "String",    ""},
97         {0, NULL, 0, NULL, NULL}
98 };
99
100 EnumPropertyItem node_math_items[] = {
101         { 0, "ADD",          0, "Add",          ""},
102         { 1, "SUBTRACT",     0, "Subtract",     ""},
103         { 2, "MULTIPLY",     0, "Multiply",     ""},
104         { 3, "DIVIDE",       0, "Divide",       ""},
105         { 4, "SINE",         0, "Sine",         ""},
106         { 5, "COSINE",       0, "Cosine",       ""},
107         { 6, "TANGENT",      0, "Tangent",      ""},
108         { 7, "ARCSINE",      0, "Arcsine",      ""},
109         { 8, "ARCCOSINE",    0, "Arccosine",    ""},
110         { 9, "ARCTANGENT",   0, "Arctangent",   ""},
111         {10, "POWER",        0, "Power",        ""},
112         {11, "LOGARITHM",    0, "Logarithm",    ""},
113         {12, "MINIMUM",      0, "Minimum",      ""},
114         {13, "MAXIMUM",      0, "Maximum",      ""},
115         {14, "ROUND",        0, "Round",        ""},
116         {15, "LESS_THAN",    0, "Less Than",    ""},
117         {16, "GREATER_THAN", 0, "Greater Than", ""},
118         {0, NULL, 0, NULL, NULL}
119 };
120
121 EnumPropertyItem node_vec_math_items[] = {
122         {0, "ADD",           0, "Add",           ""},
123         {1, "SUBTRACT",      0, "Subtract",      ""},
124         {2, "AVERAGE",       0, "Average",       ""},
125         {3, "DOT_PRODUCT",   0, "Dot Product",   ""},
126         {4, "CROSS_PRODUCT", 0, "Cross Product", ""},
127         {5, "NORMALIZE",     0, "Normalize",     ""},
128         {0, NULL, 0, NULL, NULL}
129 };
130
131 EnumPropertyItem node_filter_items[] = {
132         {0, "SOFTEN",  0, "Soften",  ""},
133         {1, "SHARPEN", 0, "Sharpen", ""},
134         {2, "LAPLACE", 0, "Laplace", ""},
135         {3, "SOBEL",   0, "Sobel",   ""},
136         {4, "PREWITT", 0, "Prewitt", ""},
137         {5, "KIRSCH",  0, "Kirsch",  ""},
138         {6, "SHADOW",  0, "Shadow",  ""},
139         {0, NULL, 0, NULL, NULL}
140 };
141
142 EnumPropertyItem node_sampler_type_items[] = {
143         {0, "NEAREST",   0, "Nearest",   ""},
144         {1, "BILINEAR",   0, "Bilinear",   ""},
145         {2, "BICUBIC", 0, "Bicubic", ""},
146         {0, NULL, 0, NULL, NULL}
147 };
148
149
150 EnumPropertyItem prop_noise_basis_items[] = {
151         {SHD_NOISE_PERLIN, "PERLIN", 0, "Perlin", ""},
152         {SHD_NOISE_VORONOI_F1, "VORONOI_F1", 0, "Voronoi F1", ""},
153         {SHD_NOISE_VORONOI_F2, "VORONOI_F2", 0, "Voronoi F2", ""},
154         {SHD_NOISE_VORONOI_F3, "VORONOI_F3", 0, "Voronoi F3", ""},
155         {SHD_NOISE_VORONOI_F4, "VORONOI_F4", 0, "Voronoi F4", ""},
156         {SHD_NOISE_VORONOI_F2_F1, "VORONOI_F2_F1", 0, "Voronoi F2-F1", ""},
157         {SHD_NOISE_VORONOI_CRACKLE, "VORONOI_CRACKLE", 0, "Voronoi Crackle", ""},
158         {SHD_NOISE_CELL_NOISE, "CELL_NOISE", 0, "Cell Noise", ""},
159         {0, NULL, 0, NULL, NULL}
160 };
161
162 EnumPropertyItem prop_noise_type_items[] = {
163         {SHD_NOISE_SOFT, "SOFT", 0, "Soft", ""},
164         {SHD_NOISE_HARD, "HARD", 0, "Hard", ""},
165         {0, NULL, 0, NULL, NULL}
166 };
167
168 #if 0
169 EnumPropertyItem prop_wave_items[] = {
170         {SHD_WAVE_SINE, "SINE", 0, "Sine", "Use a sine wave to produce bands"},
171         {SHD_WAVE_SAW, "SAW", 0, "Saw", "Use a saw wave to produce bands"},
172         {SHD_WAVE_TRI, "TRI", 0, "Tri", "Use a triangle wave to produce bands"},
173         {0, NULL, 0, NULL, NULL}
174 };
175 #endif
176
177 /* Add any new socket value subtype here.
178  * When adding a new subtype here, make sure you also add it
179  * to the subtype definitions in DNA_node_types.h.
180  * This macro is used by the RNA and the internal converter functions
181  * to define all socket subtypes. The SUBTYPE macro must be defined
182  * before using this macro, and undefined afterwards.
183  */
184 #define NODE_DEFINE_SUBTYPES_INT \
185     SUBTYPE(INT, Int, NONE, None) \
186     SUBTYPE(INT, Int, UNSIGNED, Unsigned)
187
188 #define NODE_DEFINE_SUBTYPES_FLOAT \
189     SUBTYPE(FLOAT, Float, NONE, None) \
190     SUBTYPE(FLOAT, Float, UNSIGNED, Unsigned) \
191     SUBTYPE(FLOAT, Float, PERCENTAGE, Percentage) \
192     SUBTYPE(FLOAT, Float, FACTOR, Factor) \
193     SUBTYPE(FLOAT, Float, ANGLE, Angle) \
194     SUBTYPE(FLOAT, Float, TIME, Time) \
195     SUBTYPE(FLOAT, Float, DISTANCE, Distance)
196
197 #define NODE_DEFINE_SUBTYPES_STRING \
198     SUBTYPE(STRING, String, NONE, None) \
199     SUBTYPE(STRING, String, FILEPATH, Filepath)
200
201 #define NODE_DEFINE_SUBTYPES_VECTOR \
202     SUBTYPE(VECTOR, Vector, NONE, None) \
203     SUBTYPE(VECTOR, Vector, TRANSLATION, Translation) \
204     SUBTYPE(VECTOR, Vector, DIRECTION, Direction) \
205     SUBTYPE(VECTOR, Vector, VELOCITY, Velocity) \
206     SUBTYPE(VECTOR, Vector, ACCELERATION, Acceleration) \
207     SUBTYPE(VECTOR, Vector, EULER, Euler) \
208     SUBTYPE(VECTOR, Vector, XYZ, XYZ)
209
210 #define NODE_DEFINE_SUBTYPES \
211     NODE_DEFINE_SUBTYPES_INT \
212     NODE_DEFINE_SUBTYPES_FLOAT \
213     NODE_DEFINE_SUBTYPES_STRING \
214     NODE_DEFINE_SUBTYPES_VECTOR \
215
216 #ifdef RNA_RUNTIME
217
218 #include "BLI_linklist.h"
219
220 #include "BKE_global.h"
221
222 #include "ED_node.h"
223
224 #include "RE_engine.h"
225 #include "RE_pipeline.h"
226
227 #include "DNA_scene_types.h"
228 #include "WM_api.h"
229
230 static StructRNA *rna_Node_refine(struct PointerRNA *ptr)
231 {
232         bNode *node = (bNode *)ptr->data;
233
234         switch (node->type) {
235                 
236                 #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
237                         case ID: return &RNA_##Category##StructName;
238                                 
239                 #include "rna_nodetree_types.h"
240                 
241                 case NODE_GROUP:
242                         return &RNA_NodeGroup;
243                 case NODE_FRAME:
244                         return &RNA_NodeFrame;
245                 case NODE_REROUTE:
246                         return &RNA_NodeReroute;
247                 default:
248                         return &RNA_Node;
249         }
250 }
251
252 static StructRNA *rna_NodeTree_refine(struct PointerRNA *ptr)
253 {
254         bNodeTree *ntree = (bNodeTree *)ptr->data;
255
256         switch (ntree->type) {
257                 case NTREE_SHADER:
258                         return &RNA_ShaderNodeTree;
259                 case NTREE_COMPOSIT:
260                         return &RNA_CompositorNodeTree;
261                 case NTREE_TEXTURE:
262                         return &RNA_TextureNodeTree;
263                 default:
264                         return &RNA_NodeTree;
265         }
266 }
267
268 static char *rna_Node_path(PointerRNA *ptr)
269 {
270         bNode *node = (bNode *)ptr->data;
271
272         return BLI_sprintfN("nodes[\"%s\"]", node->name);
273 }
274
275 static const char *rna_Node_get_node_type(StructRNA *type)
276 {
277         bNodeType *nodetype = RNA_struct_blender_type_get(type);
278         if (nodetype) {
279                 /* XXX hack: with customnodes branch, nodes will use an identifier string instead of integer ID.
280                  * Then this can be returned directly instead of doing this ugly include thingy ...
281                  */
282                 #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
283                 if (ID == nodetype->type) { \
284                         return EnumName; \
285                 }
286                 
287                 #include "rna_nodetree_types.h"
288         }
289         return "";
290 }
291
292 static void rna_Node_parent_set(PointerRNA *ptr, PointerRNA value)
293 {
294         bNode *node = ptr->data;
295         bNode *parent = value.data;
296         
297         if (parent) {
298                 /* XXX only Frame node allowed for now,
299                  * in the future should have a poll function or so to test possible attachment.
300                  */
301                 if (parent->type != NODE_FRAME)
302                         return;
303                 
304                 /* make sure parent is not attached to the node */
305                 if (nodeAttachNodeCheck(parent, node))
306                         return;
307         }
308         
309         nodeDetachNode(node);
310         if (parent) {
311                 nodeAttachNode(node, parent);
312         }
313 }
314
315 static int rna_Node_parent_poll(PointerRNA *ptr, PointerRNA value)
316 {
317         bNode *node = ptr->data;
318         bNode *parent = value.data;
319         
320         /* XXX only Frame node allowed for now,
321          * in the future should have a poll function or so to test possible attachment.
322          */
323         if (parent->type != NODE_FRAME)
324                 return FALSE;
325         
326         /* make sure parent is not attached to the node */
327         if (nodeAttachNodeCheck(parent, node))
328                 return FALSE;
329         
330         return TRUE;
331 }
332
333 static StructRNA *rna_NodeSocket_refine(PointerRNA *ptr)
334 {
335         bNodeSocket *sock = (bNodeSocket *)ptr->data;
336         
337         if (sock->default_value) {
338                 /* This returns the refined socket type with the full definition
339                  * of the default input value with type and subtype.
340                  */
341                 
342                 #define SUBTYPE(socktype, stypename, id, idname) \
343                 { \
344                         bNodeSocketValue##stypename *value = (bNodeSocketValue##stypename *)sock->default_value; \
345                         if (value->subtype == PROP_##id) \
346                                 return &RNA_NodeSocket##stypename##idname; \
347                 }
348                 
349                 switch (sock->type) {
350                         case SOCK_FLOAT:
351                                 NODE_DEFINE_SUBTYPES_FLOAT
352                                 break;
353                         case SOCK_INT:
354                                 NODE_DEFINE_SUBTYPES_INT
355                                 break;
356                         case SOCK_BOOLEAN:
357                                 return &RNA_NodeSocketBoolean;
358                         case SOCK_VECTOR:
359                                 NODE_DEFINE_SUBTYPES_VECTOR
360                                 break;
361                         case SOCK_STRING:
362                                 NODE_DEFINE_SUBTYPES_STRING
363                                 break;
364                         case SOCK_RGBA:
365                                 return &RNA_NodeSocketRGBA;
366                         case SOCK_SHADER:
367                                 return &RNA_NodeSocketShader;
368                 }
369                 
370                 #undef SUBTYPE
371         }
372         
373         return &RNA_NodeSocket;
374 }
375
376 static char *rna_NodeSocket_path(PointerRNA *ptr)
377 {
378         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
379         bNodeSocket *sock = (bNodeSocket *)ptr->data;
380         bNode *node;
381         int socketindex;
382         
383         /* group sockets */
384         socketindex = BLI_findindex(&ntree->inputs, sock);
385         if (socketindex != -1)
386                 return BLI_sprintfN("inputs[%d]", socketindex);
387         
388         socketindex = BLI_findindex(&ntree->outputs, sock);
389         if (socketindex != -1)
390                 return BLI_sprintfN("outputs[%d]", socketindex);
391         
392         /* node sockets */
393         if (!nodeFindNode(ntree, sock, &node, NULL, NULL)) return NULL;
394         
395         socketindex = BLI_findindex(&node->inputs, sock);
396         if (socketindex != -1)
397                 return BLI_sprintfN("nodes[\"%s\"].inputs[%d]", node->name, socketindex);
398         
399         socketindex = BLI_findindex(&node->outputs, sock);
400         if (socketindex != -1)
401                 return BLI_sprintfN("nodes[\"%s\"].outputs[%d]", node->name, socketindex);
402         
403         return NULL;
404 }
405
406 static void rna_NodeSocket_hide_set(PointerRNA *ptr, int value)
407 {
408         bNodeSocket *sock = (bNodeSocket *)ptr->data;
409         
410         /* don't hide linked sockets */
411         if (sock->flag & SOCK_IN_USE)
412                 return;
413         
414         if (value)
415                 sock->flag |= SOCK_HIDDEN;
416         else
417                 sock->flag &= ~SOCK_HIDDEN;
418 }
419
420 /* Button Set Funcs for Matte Nodes */
421 static void rna_Matte_t1_set(PointerRNA *ptr, float value)
422 {
423         bNode *node = (bNode *)ptr->data;
424         NodeChroma *chroma = node->storage;
425         
426         chroma->t1 = value;
427         
428         if (value < chroma->t2)
429                 chroma->t2 = value;
430 }
431
432 static void rna_Matte_t2_set(PointerRNA *ptr, float value)
433 {
434         bNode *node = (bNode *)ptr->data;
435         NodeChroma *chroma = node->storage;
436         
437         if (value > chroma->t1)
438                 value = chroma->t1;
439         
440         chroma->t2 = value;
441 }
442
443 static void rna_distance_matte_t1_set(PointerRNA *ptr, float value)
444 {
445         bNode *node = (bNode *)ptr->data;
446         NodeChroma *chroma = node->storage;
447
448         chroma->t1 = value;
449 }
450
451 static void rna_distance_matte_t2_set(PointerRNA *ptr, float value)
452 {
453         bNode *node = (bNode *)ptr->data;
454         NodeChroma *chroma = node->storage;
455
456         chroma->t2 = value;
457 }
458
459 static void rna_difference_matte_t1_set(PointerRNA *ptr, float value)
460 {
461         bNode *node = (bNode *)ptr->data;
462         NodeChroma *chroma = node->storage;
463
464         chroma->t1 = value;
465 }
466
467 static void rna_difference_matte_t2_set(PointerRNA *ptr, float value)
468 {
469         bNode *node = (bNode *)ptr->data;
470         NodeChroma *chroma = node->storage;
471
472         chroma->t2 = value;
473 }
474
475
476 static void rna_Node_scene_set(PointerRNA *ptr, PointerRNA value)
477 {
478         bNode *node = (bNode *)ptr->data;
479
480         if (node->id) {
481                 id_us_min(node->id);
482                 node->id = NULL;
483         }
484
485         node->id = value.data;
486
487         id_us_plus(node->id);
488 }
489
490
491
492 static void node_update(Main *bmain, Scene *UNUSED(scene), bNodeTree *ntree, bNode *node)
493 {
494         ED_node_generic_update(bmain, ntree, node);
495 }
496
497 static void rna_Node_update(Main *bmain, Scene *scene, PointerRNA *ptr)
498 {
499         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
500         bNode *node = (bNode *)ptr->data;
501
502         node_update(bmain, scene, ntree, node);
503 }
504
505 static void rna_Node_tex_image_update(Main *bmain, Scene *scene, PointerRNA *ptr)
506 {
507         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
508         bNode *node = (bNode *)ptr->data;
509
510         node_update(bmain, scene, ntree, node);
511         WM_main_add_notifier(NC_IMAGE, NULL);
512 }
513
514 static void rna_Node_material_update(Main *bmain, Scene *scene, PointerRNA *ptr)
515 {
516         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
517         bNode *node = (bNode *)ptr->data;
518
519         if (node->id)
520                 nodeSetActive(ntree, node);
521
522         node_update(bmain, scene, ntree, node);
523 }
524
525 static void rna_NodeTree_update(Main *bmain, Scene *scene, PointerRNA *ptr)
526 {
527         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
528
529         /* when using border, make it so no old data from outside of
530          * border is hanging around
531          * ideally shouldn't be in RNA callback, but how to teach
532          * compo to only clear frame when border usage is actually
533          * toggling
534          */
535         if (ntree->flag & NTREE_VIEWER_BORDER) {
536                 Image *ima = BKE_image_verify_viewer(IMA_TYPE_COMPOSITE, "Viewer Node");
537                 void *lock;
538                 ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
539
540                 if (ibuf) {
541                         if (ibuf->rect)
542                                 memset(ibuf->rect, 0, 4 * ibuf->x * ibuf->y);
543
544                         if (ibuf->rect_float)
545                                 memset(ibuf->rect_float, 0, 4 * ibuf->x * ibuf->y * sizeof(float));
546
547                         ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID;
548                 }
549
550                 BKE_image_release_ibuf(ima, ibuf, lock);
551         }
552
553         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
554         WM_main_add_notifier(NC_SCENE | ND_NODES, &ntree->id);
555 }
556
557 static void rna_NodeGroup_update(Main *bmain, Scene *scene, PointerRNA *ptr)
558 {
559         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
560         bNode *node = (bNode *)ptr->data;
561         
562         ntreeUpdateTree((bNodeTree *)node->id);
563         
564         node_update(bmain, scene, ntree, node);
565 }
566
567 static int rna_NodeGroup_node_tree_poll(PointerRNA *ptr, const PointerRNA value)
568 {
569         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
570         bNodeTree *ngroup = (bNodeTree *)value.data;
571         
572         /* only allow node trees of the same type as the group node's tree */
573         return (ngroup->type == ntree->type);
574 }
575
576 static void rna_Node_name_set(PointerRNA *ptr, const char *value)
577 {
578         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
579         bNode *node = (bNode *)ptr->data;
580         char oldname[sizeof(node->name)];
581         
582         /* make a copy of the old name first */
583         BLI_strncpy(oldname, node->name, sizeof(node->name));
584         /* set new name */
585         BLI_strncpy_utf8(node->name, value, sizeof(node->name));
586         
587         nodeUniqueName(ntree, node);
588         
589         /* fix all the animation data which may link to this */
590         BKE_all_animdata_fix_paths_rename(NULL, "nodes", oldname, node->name);
591 }
592
593 static void rna_Node_width_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
594 {
595         bNode *node = ptr->data;
596         *min = *softmin = node->typeinfo->minwidth;
597         *max = *softmax = node->typeinfo->maxwidth;
598 }
599
600 static void rna_Node_height_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
601 {
602         bNode *node = ptr->data;
603         *min = *softmin = node->typeinfo->minheight;
604         *max = *softmax = node->typeinfo->maxheight;
605 }
606
607 static void rna_NodeSocket_update(Main *bmain, Scene *scene, PointerRNA *ptr)
608 {
609         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
610         bNodeSocket *sock = (bNodeSocket *)ptr->data;
611         bNode *node;
612         
613         if (nodeFindNode(ntree, sock, &node, NULL, NULL))
614                 node_update(bmain, scene, ntree, node);
615 }
616
617 static void rna_NodeGroupSocket_update(Main *bmain, Scene *scene, PointerRNA *ptr)
618 {
619         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
620         bNodeSocket *sock = (bNodeSocket *)ptr->data;
621         bNode *node;
622         
623         ntreeUpdateTree(ntree);
624         
625         if (nodeFindNode(ntree, sock, &node, NULL, NULL))
626                 node_update(bmain, scene, ntree, node);
627 }
628
629 #if 0 /* UNUSED */
630 static void rna_NodeLink_update(Main *bmain, Scene *scene, PointerRNA *ptr)
631 {
632         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
633
634         ntree->update |= NTREE_UPDATE_LINKS;
635         ntreeUpdateTree(ntree);
636 }
637 #endif
638
639 static void rna_NodeSocketInt_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
640 {
641         bNodeSocket *sock = (bNodeSocket *)ptr->data;
642         bNodeSocketValueInt *val = (bNodeSocketValueInt *)sock->default_value;
643         *softmin = val->min;
644         *softmax = val->max;
645 }
646
647 static void rna_NodeSocketFloat_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
648 {
649         bNodeSocket *sock = (bNodeSocket *)ptr->data;
650         bNodeSocketValueFloat *val = (bNodeSocketValueFloat *)sock->default_value;
651         *softmin = val->min;
652         *softmax = val->max;
653 }
654
655 static void rna_NodeSocketVector_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
656 {
657         bNodeSocket *sock = (bNodeSocket *)ptr->data;
658         bNodeSocketValueVector *val = (bNodeSocketValueVector *)sock->default_value;
659         *softmin = val->min;
660         *softmax = val->max;
661 }
662
663 static void rna_Node_image_layer_update(Main *bmain, Scene *scene, PointerRNA *ptr)
664 {
665         bNode *node = (bNode *)ptr->data;
666         Image *ima = (Image *)node->id;
667         ImageUser *iuser = node->storage;
668         
669         BKE_image_multilayer_index(ima->rr, iuser);
670         BKE_image_signal(ima, iuser, IMA_SIGNAL_SRC_CHANGE);
671         
672         rna_Node_update(bmain, scene, ptr);
673 }
674
675 static EnumPropertyItem *renderresult_layers_add_enum(RenderLayer *rl)
676 {
677         EnumPropertyItem *item = NULL;
678         EnumPropertyItem tmp = {0, "", 0, "", ""};
679         int i = 0, totitem = 0;
680         
681         while (rl) {
682                 tmp.identifier = rl->name;
683                 /* little trick: using space char instead empty string makes the item selectable in the dropdown */
684                 if (rl->name[0] == '\0')
685                         tmp.name = " ";
686                 else
687                         tmp.name = rl->name;
688                 tmp.value = i++;
689                 RNA_enum_item_add(&item, &totitem, &tmp);
690                 rl = rl->next;
691         }
692         
693         RNA_enum_item_end(&item, &totitem);
694
695         return item;
696 }
697
698 static EnumPropertyItem *rna_Node_image_layer_itemf(bContext *UNUSED(C), PointerRNA *ptr,
699                                                     PropertyRNA *UNUSED(prop), int *free)
700 {
701         bNode *node = (bNode *)ptr->data;
702         Image *ima = (Image *)node->id;
703         EnumPropertyItem *item = NULL;
704         RenderLayer *rl;
705         
706         if (!ima || !(ima->rr)) return NULL;
707         
708         rl = ima->rr->layers.first;
709         item = renderresult_layers_add_enum(rl);
710         
711         *free = 1;
712         
713         return item;
714 }
715
716 static EnumPropertyItem *rna_Node_scene_layer_itemf(bContext *UNUSED(C), PointerRNA *ptr,
717                                                     PropertyRNA *UNUSED(prop), int *free)
718 {
719         bNode *node = (bNode *)ptr->data;
720         Scene *sce = (Scene *)node->id;
721         EnumPropertyItem *item = NULL;
722         RenderLayer *rl;
723         
724         if (!sce) return NULL;
725         
726         rl = sce->r.layers.first;
727         item = renderresult_layers_add_enum(rl);
728         
729         *free = 1;
730         
731         return item;
732 }
733
734 static EnumPropertyItem *rna_Node_channel_itemf(bContext *UNUSED(C), PointerRNA *ptr,
735                                                 PropertyRNA *UNUSED(prop), int *free)
736 {
737         bNode *node = (bNode *)ptr->data;
738         EnumPropertyItem *item = NULL;
739         EnumPropertyItem tmp = {0, "", 0, "", ""};
740         int totitem = 0;
741         
742         switch (node->custom1) {
743                 case CMP_NODE_CHANNEL_MATTE_CS_RGB:
744                         tmp.identifier = "R"; tmp.name = "R"; tmp.value = 1;
745                         RNA_enum_item_add(&item, &totitem, &tmp);
746                         tmp.identifier = "G"; tmp.name = "G"; tmp.value = 2;
747                         RNA_enum_item_add(&item, &totitem, &tmp);
748                         tmp.identifier = "B"; tmp.name = "B"; tmp.value = 3;
749                         RNA_enum_item_add(&item, &totitem, &tmp);
750                         break;
751                 case CMP_NODE_CHANNEL_MATTE_CS_HSV:
752                         tmp.identifier = "H"; tmp.name = "H"; tmp.value = 1;
753                         RNA_enum_item_add(&item, &totitem, &tmp);
754                         tmp.identifier = "S"; tmp.name = "S"; tmp.value = 2;
755                         RNA_enum_item_add(&item, &totitem, &tmp);
756                         tmp.identifier = "V"; tmp.name = "V"; tmp.value = 3;
757                         RNA_enum_item_add(&item, &totitem, &tmp);
758                         break;
759                 case CMP_NODE_CHANNEL_MATTE_CS_YUV:
760                         tmp.identifier = "Y"; tmp.name = "Y"; tmp.value = 1;
761                         RNA_enum_item_add(&item, &totitem, &tmp);
762                         tmp.identifier = "G"; tmp.name = "U"; tmp.value = 2;
763                         RNA_enum_item_add(&item, &totitem, &tmp);
764                         tmp.identifier = "V"; tmp.name = "V"; tmp.value = 3;
765                         RNA_enum_item_add(&item, &totitem, &tmp);
766                         break;
767                 case CMP_NODE_CHANNEL_MATTE_CS_YCC:
768                         tmp.identifier = "Y"; tmp.name = "Y"; tmp.value = 1;
769                         RNA_enum_item_add(&item, &totitem, &tmp);
770                         tmp.identifier = "CB"; tmp.name = "Cr"; tmp.value = 2;
771                         RNA_enum_item_add(&item, &totitem, &tmp);
772                         tmp.identifier = "CR"; tmp.name = "Cb"; tmp.value = 3;
773                         RNA_enum_item_add(&item, &totitem, &tmp);
774                         break;
775                 default:
776                         break;
777         }
778
779         RNA_enum_item_end(&item, &totitem);
780         *free = 1;
781         
782         return item;
783 }
784
785 static PointerRNA rna_NodeTree_active_node_get(PointerRNA *ptr)
786 {
787         bNodeTree *ntree = (bNodeTree *)ptr->data;
788         bNode *node = nodeGetActive(ntree);
789         return rna_pointer_inherit_refine(ptr, &RNA_Node, node);
790 }
791
792 static void rna_NodeTree_active_node_set(PointerRNA *ptr, PointerRNA value)
793 {
794         bNodeTree *ntree = (bNodeTree *)ptr->data;
795         bNode *node = (bNode *)value.data;
796         if (node && BLI_findindex(&ntree->nodes, node) != -1)
797                 nodeSetActive(ntree, node);
798         else
799                 nodeClearActive(ntree);
800 }
801
802 static bNode *rna_NodeTree_node_new(bNodeTree *ntree, bContext *C, ReportList *reports,
803                                     int type, bNodeTree *group)
804 {
805         bNode *node;
806         bNodeTemplate ntemp;
807
808         if (type == NODE_GROUP && group == NULL) {
809                 BKE_report(reports, RPT_ERROR, "Node type 'GROUP' missing group argument");
810                 return NULL;
811         }
812         
813         ntemp.type = type;
814         ntemp.ngroup = group;
815         ntemp.scene = CTX_data_scene(C);
816         ntemp.main = CTX_data_main(C);
817         node = nodeAddNode(ntree, &ntemp);
818         
819         if (node == NULL) {
820                 BKE_report(reports, RPT_ERROR, "Unable to create node");
821         }
822         else {
823                 ntreeUpdateTree(ntree); /* update group node socket links*/
824                 nodeUpdate(ntree, node);
825                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
826
827                 if (group)
828                         id_us_plus(&group->id);
829         }
830
831         return node;
832 }
833
834 static bNode *rna_NodeTree_node_composite_new(bNodeTree *ntree, bContext *C, ReportList *reports,
835                                               int type, bNodeTree *group)
836 {
837         /* raises error on failure */
838         bNode *node = rna_NodeTree_node_new(ntree, C, reports, type, group);
839         
840         if (node) {
841                 if (ELEM4(node->type, CMP_NODE_COMPOSITE, CMP_NODE_DEFOCUS, CMP_NODE_OUTPUT_FILE, CMP_NODE_R_LAYERS)) {
842                         /* annoying, find the node tree we are in, scene can be NULL */
843                         Scene *scene;
844                         for (scene = CTX_data_main(C)->scene.first; scene; scene = scene->id.next) {
845                                 if (scene->nodetree == ntree) {
846                                         break;
847                                 }
848                         }
849                         node->id = (ID *)scene;
850                         id_us_plus(node->id);
851                 }
852
853                 ntreeCompositForceHidden(ntree, CTX_data_scene(C));
854                 ntreeUpdateTree(ntree);
855         }
856
857         return node;
858 }
859
860 static bNode *rna_NodeTree_node_texture_new(bNodeTree *ntree, bContext *C, ReportList *reports,
861                                             int type, bNodeTree *group)
862 {
863         /* raises error on failure */
864         bNode *node = rna_NodeTree_node_new(ntree, C, reports, type, group);
865
866         if (node) {
867                 ntreeTexCheckCyclics(ntree);
868         }
869
870         return node;
871 }
872
873 static void rna_NodeTree_node_remove(bNodeTree *ntree, ReportList *reports, PointerRNA *node_ptr)
874 {
875         bNode *node = node_ptr->data;
876         if (BLI_findindex(&ntree->nodes, node) == -1) {
877                 BKE_reportf(reports, RPT_ERROR, "Unable to locate node '%s' in node tree", node->name);
878                 return;
879         }
880
881         id_us_min(node->id);
882         nodeFreeNode(ntree, node);
883         RNA_POINTER_INVALIDATE(node_ptr);
884
885         ntreeUpdateTree(ntree); /* update group node socket links */
886         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
887 }
888
889 static void rna_NodeTree_node_clear(bNodeTree *ntree)
890 {
891         bNode *node = ntree->nodes.first;
892
893         while (node) {
894                 bNode *next_node = node->next;
895
896                 if (node->id)
897                         id_us_min(node->id);
898
899                 nodeFreeNode(ntree, node);
900
901                 node = next_node;
902         }
903
904         ntreeUpdateTree(ntree); /* update group node socket links*/
905
906         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
907 }
908
909 static bNodeLink *rna_NodeTree_link_new(bNodeTree *ntree, ReportList *reports,
910                                         bNodeSocket *fromsock, bNodeSocket *tosock)
911 {
912         bNodeLink *ret;
913         bNode *fromnode = NULL, *tonode = NULL;
914         int from_in_out, to_in_out;
915
916         nodeFindNode(ntree, fromsock, &fromnode, NULL, &from_in_out);
917         nodeFindNode(ntree, tosock, &tonode, NULL, &to_in_out);
918         
919         if (&from_in_out == &to_in_out) {
920                 BKE_report(reports, RPT_ERROR, "Same input/output direction of sockets");
921                 return NULL;
922         }
923
924         /* unlink node input socket */
925         if (to_in_out == SOCK_IN)
926                 nodeRemSocketLinks(ntree, tosock);
927         else
928                 nodeRemSocketLinks(ntree, fromsock);
929
930         ret = nodeAddLink(ntree, fromnode, fromsock, tonode, tosock);
931         
932         if (ret) {
933                 if (tonode)
934                         nodeUpdate(ntree, tonode);
935
936                 ntreeUpdateTree(ntree);
937
938                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
939         }
940
941         return ret;
942 }
943
944 static void rna_NodeTree_link_remove(bNodeTree *ntree, ReportList *reports, PointerRNA *link_ptr)
945 {
946         bNodeLink *link = link_ptr->data;
947         if (BLI_findindex(&ntree->links, link) == -1) {
948                 BKE_report(reports, RPT_ERROR, "Unable to locate link in node tree");
949                 return;
950         }
951
952         nodeRemLink(ntree, link);
953         RNA_POINTER_INVALIDATE(link_ptr);
954
955         ntreeUpdateTree(ntree);
956         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
957 }
958
959 static void rna_NodeTree_link_clear(bNodeTree *ntree)
960 {
961         bNodeLink *link = ntree->links.first;
962
963         while (link) {
964                 bNodeLink *next_link = link->next;
965
966                 nodeRemLink(ntree, link);
967
968                 link = next_link;
969         }
970         ntreeUpdateTree(ntree);
971
972         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
973 }
974
975 static bNodeSocket *rna_NodeTree_input_new(bNodeTree *ntree, ReportList *UNUSED(reports), const char *name, int type)
976 {
977         /* XXX should check if tree is a group here! no good way to do this currently. */
978         bNodeSocket *gsock = node_group_add_socket(ntree, name, type, SOCK_IN);
979         
980         ntree->update |= NTREE_UPDATE_GROUP_IN;
981         ntreeUpdateTree(ntree);
982         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
983         return gsock;
984 }
985
986 static bNodeSocket *rna_NodeTree_output_new(bNodeTree *ntree, ReportList *UNUSED(reports), const char *name, int type)
987 {
988         /* XXX should check if tree is a group here! no good way to do this currently. */
989         bNodeSocket *gsock = node_group_add_socket(ntree, name, type, SOCK_OUT);
990         
991         ntree->update |= NTREE_UPDATE_GROUP_OUT;
992         ntreeUpdateTree(ntree);
993         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
994         return gsock;
995 }
996
997 static bNodeSocket *rna_NodeTree_input_expose(bNodeTree *ntree, ReportList *reports, bNodeSocket *sock, int add_link)
998 {
999         bNode *node;
1000         bNodeSocket *gsock;
1001         int index, in_out;
1002         
1003         if (!nodeFindNode(ntree, sock, &node, &index, &in_out))
1004                 BKE_report(reports, RPT_ERROR, "Unable to locate socket in node tree");
1005         else if (in_out != SOCK_IN)
1006                 BKE_report(reports, RPT_ERROR, "Socket is not an input");
1007         else {
1008                 /* XXX should check if tree is a group here! no good way to do this currently. */
1009                 gsock = node_group_add_socket(ntree, sock->name, sock->type, SOCK_IN);
1010                 if (add_link)
1011                         nodeAddLink(ntree, NULL, gsock, node, sock);
1012                 
1013                 ntree->update |= NTREE_UPDATE_GROUP_IN;
1014                 ntreeUpdateTree(ntree);
1015                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1016                 return gsock;
1017         }
1018         return NULL;
1019 }
1020
1021 static bNodeSocket *rna_NodeTree_output_expose(bNodeTree *ntree, ReportList *reports, bNodeSocket *sock, int add_link)
1022 {
1023         bNode *node;
1024         bNodeSocket *gsock;
1025         int index, in_out;
1026         
1027         if (!nodeFindNode(ntree, sock, &node, &index, &in_out))
1028                 BKE_report(reports, RPT_ERROR, "Unable to locate socket in node tree");
1029         else if (in_out != SOCK_OUT)
1030                 BKE_report(reports, RPT_ERROR, "Socket is not an output");
1031         else {
1032                 /* XXX should check if tree is a group here! no good way to do this currently. */
1033                 gsock = node_group_add_socket(ntree, sock->name, sock->type, SOCK_OUT);
1034                 if (add_link)
1035                         nodeAddLink(ntree, node, sock, NULL, gsock);
1036                 
1037                 ntree->update |= NTREE_UPDATE_GROUP_OUT;
1038                 ntreeUpdateTree(ntree);
1039                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1040                 return gsock;
1041         }
1042         return NULL;
1043 }
1044
1045 static void rna_Image_Node_update_id(Main *bmain, Scene *scene, PointerRNA *ptr)
1046 {
1047         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1048         bNode *node = (bNode *)ptr->data;
1049
1050         node->update |= NODE_UPDATE_ID;
1051         node_update(bmain, scene, ntree, node);
1052         node->update &= ~NODE_UPDATE_ID;
1053 }
1054
1055 static void rna_Mapping_Node_update(Main *bmain, Scene *scene, PointerRNA *ptr)
1056 {
1057         bNode *node = ptr->data;
1058         init_tex_mapping(node->storage);
1059         rna_Node_update(bmain, scene, ptr);
1060 }
1061
1062 static void rna_NodeOutputFile_slots_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
1063 {
1064         bNode *node = ptr->data;
1065         rna_iterator_listbase_begin(iter, &node->inputs, NULL);
1066 }
1067
1068 static PointerRNA rna_NodeOutputFile_slot_file_get(CollectionPropertyIterator *iter)
1069 {
1070         PointerRNA ptr;
1071         bNodeSocket *sock = rna_iterator_listbase_get(iter);
1072         RNA_pointer_create(iter->parent.id.data, &RNA_NodeOutputFileSlotFile, sock->storage, &ptr);
1073         return ptr;
1074 }
1075
1076 static PointerRNA rna_NodeOutputFile_slot_layer_get(CollectionPropertyIterator *iter)
1077 {
1078         PointerRNA ptr;
1079         bNodeSocket *sock = rna_iterator_listbase_get(iter);
1080         RNA_pointer_create(iter->parent.id.data, &RNA_NodeOutputFileSlotLayer, sock->storage, &ptr);
1081         return ptr;
1082 }
1083
1084 static int rna_NodeOutputFileSocket_find_node(bNodeTree *ntree, NodeImageMultiFileSocket *data, bNode **nodep, bNodeSocket **sockp)
1085 {
1086         bNode *node;
1087         bNodeSocket *sock;
1088         
1089         for (node = ntree->nodes.first; node; node = node->next) {
1090                 for (sock = node->inputs.first; sock; sock = sock->next) {
1091                         NodeImageMultiFileSocket *sockdata = sock->storage;
1092                         if (sockdata == data) {
1093                                 *nodep = node;
1094                                 *sockp = sock;
1095                                 return 1;
1096                         }
1097                 }
1098         }
1099         
1100         *nodep = NULL;
1101         *sockp = NULL;
1102         return 0;
1103 }
1104
1105 static void rna_NodeOutputFileSlotFile_path_set(PointerRNA *ptr, const char *value)
1106 {
1107         bNodeTree *ntree = ptr->id.data;
1108         NodeImageMultiFileSocket *sockdata = ptr->data;
1109         bNode *node;
1110         bNodeSocket *sock;
1111         
1112         if (rna_NodeOutputFileSocket_find_node(ntree, sockdata, &node, &sock)) {
1113                 ntreeCompositOutputFileSetPath(node, sock, value);
1114         }
1115 }
1116
1117 static void rna_NodeOutputFileSlotLayer_name_set(PointerRNA *ptr, const char *value)
1118 {
1119         bNodeTree *ntree = ptr->id.data;
1120         NodeImageMultiFileSocket *sockdata = ptr->data;
1121         bNode *node;
1122         bNodeSocket *sock;
1123         
1124         if (rna_NodeOutputFileSocket_find_node(ntree, sockdata, &node, &sock)) {
1125                 ntreeCompositOutputFileSetLayer(node, sock, value);
1126         }
1127 }
1128
1129 static bNodeSocket *rna_ShaderNodeScript_find_socket(bNode *node, const char *name, int is_output)
1130 {
1131         bNodeSocket *sock;
1132
1133         if (is_output) {
1134                 for (sock = node->outputs.first; sock; sock = sock->next) {
1135                         if (strcmp(sock->name, name) == 0) {
1136                                 return sock;
1137                         }
1138                 }
1139         }
1140         else {
1141                 for (sock = node->inputs.first; sock; sock = sock->next) {
1142                         if (strcmp(sock->name, name) == 0) {
1143                                 return sock;
1144                         }
1145                 }
1146         }
1147
1148         return NULL;
1149 }
1150
1151 static void rna_ShaderNodeScript_remove_socket(ID *id, bNode *node, bNodeSocket *sock)
1152 {
1153         bNodeTree *ntree = (bNodeTree *)id;
1154         
1155         nodeRemoveSocket(ntree, node, sock);
1156         
1157         ED_node_generic_update(G.main, ntree, node);
1158 }
1159
1160 static bNodeSocket *rna_ShaderNodeScript_add_socket(ID *id, bNode *node, const char *name, int type, int is_output)
1161 {
1162         bNodeTree *ntree = (bNodeTree *)id;
1163         bNodeSocket *sock;
1164         
1165         /* replace existing socket with the same name, to keep it unique */
1166         sock = rna_ShaderNodeScript_find_socket(node, name, is_output);
1167         if (sock)
1168                 nodeRemoveSocket(ntree, node, sock);
1169         sock = nodeAddSocket(ntree, node, (is_output ? SOCK_OUT : SOCK_IN), name, type);
1170         
1171         ED_node_generic_update(G.main, ntree, node);
1172         
1173         return sock;
1174 }
1175
1176 static void rna_ShaderNodeScript_mode_set(PointerRNA *ptr, int value)
1177 {
1178         bNode *node = (bNode *)ptr->data;
1179         NodeShaderScript *nss = node->storage;
1180
1181         if (nss->mode != value) {
1182                 nss->mode = value;
1183                 nss->filepath[0] = '\0';
1184                 nss->flag &= ~NODE_SCRIPT_AUTO_UPDATE;
1185
1186                 /* replace text datablock by filepath */
1187                 if (node->id) {
1188                         Text *text = (Text *)node->id;
1189
1190                         if (value == NODE_SCRIPT_EXTERNAL && text->name) {
1191                                 BLI_strncpy(nss->filepath, text->name, sizeof(nss->filepath));
1192                                 BLI_path_rel(nss->filepath, G.main->name);
1193                         }
1194
1195                         id_us_min(node->id);
1196                         node->id = NULL;
1197                 }
1198
1199                 /* remove any bytecode */
1200                 if (nss->bytecode) {
1201                         MEM_freeN(nss->bytecode);
1202                         nss->bytecode = NULL;
1203                 }
1204
1205                 nss->bytecode_hash[0] = '\0';
1206         }
1207 }
1208
1209 static void rna_ShaderNodeScript_bytecode_get(PointerRNA *ptr, char *value)
1210 {
1211         bNode *node = (bNode *)ptr->data;
1212         NodeShaderScript *nss = node->storage;
1213
1214         strcpy(value, (nss->bytecode)? nss->bytecode: "");
1215 }
1216
1217 static int rna_ShaderNodeScript_bytecode_length(PointerRNA *ptr)
1218 {
1219         bNode *node = (bNode *)ptr->data;
1220         NodeShaderScript *nss = node->storage;
1221
1222         return (nss->bytecode) ? strlen(nss->bytecode) : 0;
1223 }
1224
1225 static void rna_ShaderNodeScript_bytecode_set(PointerRNA *ptr, const char *value)
1226 {
1227         bNode *node = (bNode *)ptr->data;
1228         NodeShaderScript *nss = node->storage;
1229
1230         if (nss->bytecode)
1231                 MEM_freeN(nss->bytecode);
1232
1233         if (value && value[0])
1234                 nss->bytecode = BLI_strdup(value);
1235         else
1236                 nss->bytecode = NULL;
1237 }
1238
1239 static IDProperty *rna_ShaderNodeScript_idprops(PointerRNA *ptr, bool create)
1240 {
1241         bNode *node = (bNode *)ptr->data;
1242         NodeShaderScript *nss = node->storage;
1243
1244         if (create && !nss->prop) {
1245                 IDPropertyTemplate val = {0};
1246                 nss->prop = IDP_New(IDP_GROUP, &val, "RNA_ShaderNodeScript ID properties");
1247         }
1248
1249         return nss->prop;
1250 }
1251
1252 static void rna_ShaderNodeScript_update(Main *bmain, Scene *scene, PointerRNA *ptr)
1253 {
1254         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1255         bNode *node = (bNode *)ptr->data;
1256         RenderEngineType *engine_type = RE_engines_find(scene->r.engine);
1257
1258         if (engine_type && engine_type->update_script_node) {
1259                 /* auto update node */
1260                 RenderEngine *engine = RE_engine_create(engine_type);
1261                 engine_type->update_script_node(engine, ntree, node);
1262                 RE_engine_free(engine);
1263         }
1264
1265         node_update(bmain, scene, ntree, node);
1266 }
1267
1268 #else
1269
1270 static EnumPropertyItem prop_image_layer_items[] = {
1271         { 0, "PLACEHOLDER",          0, "Placeholder",          ""},
1272         {0, NULL, 0, NULL, NULL}
1273 };
1274
1275 static EnumPropertyItem prop_scene_layer_items[] = {
1276         { 0, "PLACEHOLDER",          0, "Placeholder",          ""},
1277         {0, NULL, 0, NULL, NULL}
1278 };
1279
1280 static EnumPropertyItem prop_tri_channel_items[] = {
1281         { 1, "R", 0, "R", ""},
1282         { 2, "G", 0, "G", ""},
1283         { 3, "B", 0, "B", ""},
1284         {0, NULL, 0, NULL, NULL}
1285 };
1286
1287 static EnumPropertyItem node_flip_items[] = {
1288         {0, "X",  0, "Flip X",     ""},
1289         {1, "Y",  0, "Flip Y",     ""},
1290         {2, "XY", 0, "Flip X & Y", ""},
1291         {0, NULL, 0, NULL, NULL}
1292 };
1293
1294 static EnumPropertyItem node_ycc_items[] = {
1295         { 0, "ITUBT601", 0, "ITU 601",  ""},
1296         { 1, "ITUBT709", 0, "ITU 709",  ""},
1297         { 2, "JFIF",     0, "Jpeg",     ""},
1298         {0, NULL, 0, NULL, NULL}
1299 };
1300
1301 static EnumPropertyItem node_glossy_items[] = {
1302         {SHD_GLOSSY_SHARP,    "SHARP",    0, "Sharp",    ""},
1303         {SHD_GLOSSY_BECKMANN, "BECKMANN", 0, "Beckmann", ""},
1304         {SHD_GLOSSY_GGX,      "GGX",      0, "GGX",      ""},
1305         {0, NULL, 0, NULL, NULL}
1306 };
1307
1308 static EnumPropertyItem node_script_mode_items[] = {
1309         {NODE_SCRIPT_INTERNAL, "INTERNAL", 0, "Internal", "Use internal text datablock"},
1310         {NODE_SCRIPT_EXTERNAL, "EXTERNAL", 0, "External", "Use external .osl or .oso file"},
1311         {0, NULL, 0, NULL, NULL}
1312 };
1313
1314 #define MaxNodes 50000
1315
1316 enum
1317 {
1318         Category_GroupNode,
1319         Category_LayoutNode,
1320         Category_ShaderNode,
1321         Category_CompositorNode,
1322         Category_TextureNode,
1323 };
1324
1325 typedef struct NodeInfo {
1326         int defined;
1327         int category;
1328         const char *enum_name;
1329         const char *struct_name;
1330         const char *base_name;
1331         int icon;
1332         const char *ui_name;
1333         const char *ui_desc;
1334 } NodeInfo;
1335
1336 static NodeInfo nodes[MaxNodes];
1337
1338 static void reg_node(int ID, int category, const char *enum_name, const char *struct_name,
1339                      const char *base_name, const char *ui_name, const char *ui_desc)
1340 {
1341         NodeInfo *ni = nodes + ID;
1342         
1343         ni->defined = 1;
1344         ni->category = category;
1345         ni->enum_name = enum_name;
1346         ni->struct_name = struct_name;
1347         ni->base_name = base_name;
1348         ni->ui_name = ui_name;
1349         ni->ui_desc = ui_desc;
1350 }
1351
1352 static void init(void)
1353 {
1354         memset(nodes, 0, sizeof(nodes));
1355         
1356         #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
1357                 reg_node(ID, Category_##Category, EnumName, STRINGIFY_ARG(Category##StructName), #Category, UIName, UIDesc);
1358                 
1359         #include "rna_nodetree_types.h"
1360         
1361         reg_node(NODE_GROUP, Category_GroupNode, "GROUP", "NodeGroup", "SpecialNode", "Group", "");
1362         reg_node(NODE_FRAME, Category_LayoutNode, "FRAME", "NodeFrame", "SpecialNode", "Frame", "");
1363         reg_node(NODE_REROUTE, Category_LayoutNode, "REROUTE", "NodeReroute", "SpecialNode", "Reroute", "");
1364 }
1365
1366 static StructRNA *def_node(BlenderRNA *brna, int node_id)
1367 {
1368         StructRNA *srna;
1369         FunctionRNA *func;
1370         PropertyRNA *parm;
1371         NodeInfo *node = nodes + node_id;
1372         
1373         srna = RNA_def_struct(brna, node->struct_name, node->base_name);
1374         RNA_def_struct_ui_text(srna, node->ui_name, node->ui_desc);
1375         RNA_def_struct_sdna(srna, "bNode");
1376         
1377         func = RNA_def_function(srna, "get_node_type", "rna_Node_get_node_type");
1378         RNA_def_function_ui_description(func, "Get the identifier of the node type");
1379         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_SELF_TYPE);
1380         parm = RNA_def_string(func, "result", "", 0, "Result", "");
1381         RNA_def_function_return(func, parm);
1382         
1383         return srna;
1384 }
1385
1386 static void alloc_node_type_items(EnumPropertyItem *items, int category)
1387 {
1388         int i;
1389         int count = 4;
1390         EnumPropertyItem *item  = items;
1391         
1392         for (i = 0; i < MaxNodes; i++)
1393                 if (nodes[i].defined && nodes[i].category == category)
1394                         count++;
1395                 
1396         /*item = items = MEM_callocN(count * sizeof(EnumPropertyItem), "alloc_node_type_items");*/
1397         
1398         for (i = 0; i < MaxNodes; i++) {
1399                 NodeInfo *node = nodes + i;
1400                 if (node->defined && node->category == category) {
1401                         item->value = i;
1402                         item->identifier = node->enum_name;
1403                         item->icon = node->icon;
1404                         item->name = node->ui_name;
1405                         item->description = node->ui_desc;
1406                 
1407                         item++;
1408                 }
1409         }
1410
1411         item->value = NODE_GROUP;
1412         item->identifier = "GROUP";
1413         item->icon = 0;
1414         item->name = "Group";
1415         item->description = "";
1416         
1417         item++;
1418         
1419         item->value = NODE_REROUTE;
1420         item->identifier = "REROUTE";
1421         item->icon = 0;
1422         item->name = "Reroute";
1423         item->description = "";
1424         
1425         item++;
1426         
1427         item->value = NODE_FRAME;
1428         item->identifier = "FRAME";
1429         item->icon = 0;
1430         item->name = "Frame";
1431         item->description = "";
1432         
1433         item++;
1434         
1435         /* NOTE!, increase 'count' when adding items here */
1436         
1437         memset(item, 0, sizeof(EnumPropertyItem));
1438 }
1439
1440
1441 /* -- Common nodes ---------------------------------------------------------- */
1442
1443 static void def_group(StructRNA *srna)
1444 {
1445         PropertyRNA *prop;
1446         
1447         prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
1448         RNA_def_property_pointer_sdna(prop, NULL, "id");
1449         RNA_def_property_struct_type(prop, "NodeTree");
1450         RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_NodeGroup_node_tree_poll");
1451         RNA_def_property_flag(prop, PROP_EDITABLE);
1452         RNA_def_property_ui_text(prop, "Node Tree", "");
1453         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeGroup_update");
1454 }
1455
1456 static void def_frame(StructRNA *srna)
1457 {
1458         PropertyRNA *prop; 
1459         
1460         RNA_def_struct_sdna_from(srna, "NodeFrame", "storage");
1461         
1462         prop = RNA_def_property(srna, "shrink", PROP_BOOLEAN, PROP_NONE);
1463         RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_FRAME_SHRINK);
1464         RNA_def_property_ui_text(prop, "Shrink", "Shrink the frame to minimal bounding box");
1465         RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL);
1466
1467         prop = RNA_def_property(srna, "label_size", PROP_INT, PROP_NONE);
1468         RNA_def_property_int_sdna(prop, NULL, "label_size");
1469         RNA_def_property_range(prop, 8, 64);
1470         RNA_def_property_ui_text(prop, "Label Font Size", "Font size to use for displaying the label");
1471         RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL);
1472 }
1473
1474 static void def_math(StructRNA *srna)
1475 {
1476         PropertyRNA *prop;
1477         
1478         prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
1479         RNA_def_property_enum_sdna(prop, NULL, "custom1");
1480         RNA_def_property_enum_items(prop, node_math_items);
1481         RNA_def_property_ui_text(prop, "Operation", "");
1482         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1483
1484         prop = RNA_def_property(srna, "use_clamp", PROP_BOOLEAN, PROP_NONE);
1485         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 1);
1486         RNA_def_property_ui_text(prop, "Clamp", "Clamp result of the node to 0..1 range");
1487         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1488 }
1489
1490 static void def_vector_math(StructRNA *srna)
1491 {
1492         PropertyRNA *prop;
1493         
1494         prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
1495         RNA_def_property_enum_sdna(prop, NULL, "custom1");
1496         RNA_def_property_enum_items(prop, node_vec_math_items);
1497         RNA_def_property_ui_text(prop, "Operation", "");
1498         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1499 }
1500
1501 static void def_rgb_curve(StructRNA *srna)
1502 {
1503         PropertyRNA *prop;
1504         
1505         prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
1506         RNA_def_property_pointer_sdna(prop, NULL, "storage");
1507         RNA_def_property_struct_type(prop, "CurveMapping");
1508         RNA_def_property_ui_text(prop, "Mapping", "");
1509         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1510 }
1511
1512 static void def_vector_curve(StructRNA *srna)
1513 {
1514         PropertyRNA *prop;
1515         
1516         prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
1517         RNA_def_property_pointer_sdna(prop, NULL, "storage");
1518         RNA_def_property_struct_type(prop, "CurveMapping");
1519         RNA_def_property_ui_text(prop, "Mapping", "");
1520         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1521 }
1522
1523 static void def_time(StructRNA *srna)
1524 {
1525         PropertyRNA *prop;
1526         
1527         prop = RNA_def_property(srna, "curve", PROP_POINTER, PROP_NONE);
1528         RNA_def_property_pointer_sdna(prop, NULL, "storage");
1529         RNA_def_property_struct_type(prop, "CurveMapping");
1530         RNA_def_property_ui_text(prop, "Curve", "");
1531         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1532         
1533         prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_NONE);
1534         RNA_def_property_int_sdna(prop, NULL, "custom1");
1535         RNA_def_property_ui_text(prop, "Start Frame", "");
1536         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1537         
1538         prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_NONE);
1539         RNA_def_property_int_sdna(prop, NULL, "custom2");
1540         RNA_def_property_ui_text(prop, "End Frame", "");
1541         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1542 }
1543
1544 static void def_colorramp(StructRNA *srna)
1545 {
1546         PropertyRNA *prop;
1547         
1548         prop = RNA_def_property(srna, "color_ramp", PROP_POINTER, PROP_NONE);
1549         RNA_def_property_pointer_sdna(prop, NULL, "storage");
1550         RNA_def_property_struct_type(prop, "ColorRamp");
1551         RNA_def_property_ui_text(prop, "Color Ramp", "");
1552         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1553 }
1554
1555 static void def_mix_rgb(StructRNA *srna)
1556 {
1557         PropertyRNA *prop;
1558         
1559         prop = RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
1560         RNA_def_property_enum_sdna(prop, NULL, "custom1");
1561         RNA_def_property_enum_items(prop, ramp_blend_items);
1562         RNA_def_property_ui_text(prop, "Blend Type", "");
1563         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1564         
1565         prop = RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
1566         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 1);
1567         RNA_def_property_ui_text(prop, "Alpha", "Include alpha of second input in this operation");
1568         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1569
1570         prop = RNA_def_property(srna, "use_clamp", PROP_BOOLEAN, PROP_NONE);
1571         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 2);
1572         RNA_def_property_ui_text(prop, "Clamp", "Clamp result of the node to 0..1 range");
1573         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1574 }
1575
1576 static void def_texture(StructRNA *srna)
1577 {
1578         PropertyRNA *prop;
1579         
1580         prop = RNA_def_property(srna, "texture", PROP_POINTER, PROP_NONE);
1581         RNA_def_property_pointer_sdna(prop, NULL, "id");
1582         RNA_def_property_struct_type(prop, "Texture");
1583         RNA_def_property_flag(prop, PROP_EDITABLE);
1584         RNA_def_property_ui_text(prop, "Texture", "");
1585         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1586         
1587         prop = RNA_def_property(srna, "node_output", PROP_INT, PROP_NONE);
1588         RNA_def_property_int_sdna(prop, NULL, "custom1");
1589         RNA_def_property_ui_text(prop, "Node Output", "For node-based textures, which output node to use");
1590         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1591 }
1592
1593
1594 /* -- Shader Nodes ---------------------------------------------------------- */
1595
1596 static void def_sh_material(StructRNA *srna)
1597 {
1598         PropertyRNA *prop;
1599
1600         prop = RNA_def_property(srna, "material", PROP_POINTER, PROP_NONE);
1601         RNA_def_property_pointer_sdna(prop, NULL, "id");
1602         RNA_def_property_struct_type(prop, "Material");
1603         RNA_def_property_flag(prop, PROP_EDITABLE);
1604         RNA_def_property_ui_text(prop, "Material", "");
1605         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_material_update");
1606
1607         prop = RNA_def_property(srna, "use_diffuse", PROP_BOOLEAN, PROP_NONE);
1608         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_DIFF);
1609         RNA_def_property_ui_text(prop, "Diffuse", "Material Node outputs Diffuse");
1610         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1611
1612         prop = RNA_def_property(srna, "use_specular", PROP_BOOLEAN, PROP_NONE);
1613         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_SPEC);
1614         RNA_def_property_ui_text(prop, "Specular", "Material Node outputs Specular");
1615         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1616         
1617         prop = RNA_def_property(srna, "invert_normal", PROP_BOOLEAN, PROP_NONE);
1618         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_NEG);
1619         RNA_def_property_ui_text(prop, "Invert Normal", "Material Node uses inverted normal");
1620         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1621 }
1622
1623 static void def_sh_mapping(StructRNA *srna)
1624 {
1625         PropertyRNA *prop;
1626         
1627         RNA_def_struct_sdna_from(srna, "TexMapping", "storage");
1628
1629         prop = RNA_def_property(srna, "translation", PROP_FLOAT, PROP_TRANSLATION);
1630         RNA_def_property_float_sdna(prop, NULL, "loc");
1631         RNA_def_property_ui_text(prop, "Location", "");
1632         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
1633         
1634         /* Not PROP_XYZ, this is now in radians, no more degrees */
1635         prop = RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_EULER);
1636         RNA_def_property_float_sdna(prop, NULL, "rot");
1637         RNA_def_property_ui_text(prop, "Rotation", "");
1638         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
1639         
1640         prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
1641         RNA_def_property_float_sdna(prop, NULL, "size");
1642         RNA_def_property_ui_text(prop, "Scale", "");
1643         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
1644         
1645         prop = RNA_def_property(srna, "min", PROP_FLOAT, PROP_XYZ);
1646         RNA_def_property_float_sdna(prop, NULL, "min");
1647         RNA_def_property_ui_text(prop, "Minimum", "Minimum value for clipping");
1648         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
1649         
1650         prop = RNA_def_property(srna, "max", PROP_FLOAT, PROP_XYZ);
1651         RNA_def_property_float_sdna(prop, NULL, "max");
1652         RNA_def_property_ui_text(prop, "Maximum", "Maximum value for clipping");
1653         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
1654         
1655         prop = RNA_def_property(srna, "use_min", PROP_BOOLEAN, PROP_NONE);
1656         RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MIN);
1657         RNA_def_property_ui_text(prop, "Has Minimum", "Whether to use minimum clipping value");
1658         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
1659         
1660         prop = RNA_def_property(srna, "use_max", PROP_BOOLEAN, PROP_NONE);
1661         RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MAX);
1662         RNA_def_property_ui_text(prop, "Has Maximum", "Whether to use maximum clipping value");
1663         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
1664 }
1665
1666 static void def_sh_geometry(StructRNA *srna)
1667 {
1668         PropertyRNA *prop;
1669         
1670         RNA_def_struct_sdna_from(srna, "NodeGeometry", "storage");
1671         
1672         prop = RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE);
1673         RNA_def_property_string_sdna(prop, NULL, "uvname");
1674         RNA_def_property_ui_text(prop, "UV Map", "");
1675         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1676         
1677         prop = RNA_def_property(srna, "color_layer", PROP_STRING, PROP_NONE);
1678         RNA_def_property_string_sdna(prop, NULL, "colname");
1679         RNA_def_property_ui_text(prop, "Vertex Color Layer", "");
1680         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1681 }
1682
1683 static void def_sh_attribute(StructRNA *srna)
1684 {
1685         PropertyRNA *prop;
1686         
1687         RNA_def_struct_sdna_from(srna, "NodeShaderAttribute", "storage");
1688         
1689         prop = RNA_def_property(srna, "attribute_name", PROP_STRING, PROP_NONE);
1690         RNA_def_property_string_sdna(prop, NULL, "name");
1691         RNA_def_property_ui_text(prop, "Attribute Name", "");
1692         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1693 }
1694
1695 static void def_sh_tex(StructRNA *srna)
1696 {
1697         PropertyRNA *prop;
1698
1699         prop = RNA_def_property(srna, "texture_mapping", PROP_POINTER, PROP_NONE);
1700         RNA_def_property_pointer_sdna(prop, NULL, "base.tex_mapping");
1701         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1702         RNA_def_property_ui_text(prop, "Texture Mapping", "Texture coordinate mapping settings");
1703
1704         prop = RNA_def_property(srna, "color_mapping", PROP_POINTER, PROP_NONE);
1705         RNA_def_property_pointer_sdna(prop, NULL, "base.color_mapping");
1706         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1707         RNA_def_property_ui_text(prop, "Color Mapping", "Color mapping settings");
1708 }
1709
1710 static void def_sh_tex_sky(StructRNA *srna)
1711 {
1712         PropertyRNA *prop;
1713         
1714         RNA_def_struct_sdna_from(srna, "NodeTexSky", "storage");
1715         def_sh_tex(srna);
1716         
1717         prop = RNA_def_property(srna, "sun_direction", PROP_FLOAT, PROP_DIRECTION);
1718         RNA_def_property_ui_text(prop, "Sun Direction", "Direction from where the sun is shining");
1719         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1720         
1721         prop = RNA_def_property(srna, "turbidity", PROP_FLOAT, PROP_NONE);
1722         RNA_def_property_range(prop, 1.0f, 30.0f);
1723         RNA_def_property_ui_text(prop, "Turbidity", "Atmospheric turbidity");
1724         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1725 }
1726
1727 static void def_sh_tex_environment(StructRNA *srna)
1728 {
1729         static const EnumPropertyItem prop_color_space_items[] = {
1730                 {SHD_COLORSPACE_COLOR, "COLOR", 0, "Color",
1731                                        "Image contains color data, and will be converted to linear color for rendering"},
1732                 {SHD_COLORSPACE_NONE, "NONE", 0, "Non-Color Data",
1733                                       "Image contains non-color data, for example a displacement or normal map, "
1734                                       "and will not be converted"},
1735                 {0, NULL, 0, NULL, NULL}
1736         };
1737
1738         static const EnumPropertyItem prop_projection_items[] = {
1739                 {SHD_PROJ_EQUIRECTANGULAR, "EQUIRECTANGULAR", 0, "Equirectangular",
1740                                            "Equirectangular or latitude-longitude projection"},
1741                 {SHD_PROJ_MIRROR_BALL, "MIRROR_BALL", 0, "Mirror Ball",
1742                                        "Projection from an orthographic photo of a mirror ball"},
1743                 {0, NULL, 0, NULL, NULL}
1744         };
1745         
1746         PropertyRNA *prop;
1747
1748         prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
1749         RNA_def_property_pointer_sdna(prop, NULL, "id");
1750         RNA_def_property_struct_type(prop, "Image");
1751         RNA_def_property_flag(prop, PROP_EDITABLE);
1752         RNA_def_property_ui_text(prop, "Image", "");
1753         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_tex_image_update");
1754
1755         RNA_def_struct_sdna_from(srna, "NodeTexEnvironment", "storage");
1756         def_sh_tex(srna);
1757
1758         prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
1759         RNA_def_property_enum_items(prop, prop_color_space_items);
1760         RNA_def_property_ui_text(prop, "Color Space", "Image file color space");
1761         RNA_def_property_update(prop, 0, "rna_Node_update");
1762
1763         prop = RNA_def_property(srna, "projection", PROP_ENUM, PROP_NONE);
1764         RNA_def_property_enum_items(prop, prop_projection_items);
1765         RNA_def_property_ui_text(prop, "Projection", "Projection of the input image");
1766         RNA_def_property_update(prop, 0, "rna_Node_update");
1767
1768         prop = RNA_def_property(srna, "image_user", PROP_POINTER, PROP_NONE);
1769         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1770         RNA_def_property_pointer_sdna(prop, NULL, "iuser");
1771         RNA_def_property_ui_text(prop, "Image User",
1772                                  "Parameters defining which layer, pass and frame of the image is displayed");
1773         RNA_def_property_update(prop, 0, "rna_Node_update");
1774 }
1775
1776 static void def_sh_tex_image(StructRNA *srna)
1777 {
1778         static const EnumPropertyItem prop_color_space_items[] = {
1779                 {SHD_COLORSPACE_COLOR, "COLOR", 0, "Color",
1780                                        "Image contains color data, and will be converted to linear color for rendering"},
1781                 {SHD_COLORSPACE_NONE, "NONE", 0, "Non-Color Data",
1782                                       "Image contains non-color data, for example a displacement or normal map, "
1783                                       "and will not be converted"},
1784                 {0, NULL, 0, NULL, NULL}
1785         };
1786
1787         static const EnumPropertyItem prop_projection_items[] = {
1788                 {SHD_PROJ_FLAT, "FLAT", 0, "Flat",
1789                                 "Image is projected flat using the X and Y coordinates of the texture vector"},
1790                 {SHD_PROJ_BOX,  "BOX", 0, "Box",
1791                                 "Image is projected using different components for each side of the object space bounding box"},
1792                 {0, NULL, 0, NULL, NULL}
1793         };
1794
1795
1796         PropertyRNA *prop;
1797
1798         prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
1799         RNA_def_property_pointer_sdna(prop, NULL, "id");
1800         RNA_def_property_struct_type(prop, "Image");
1801         RNA_def_property_flag(prop, PROP_EDITABLE);
1802         RNA_def_property_ui_text(prop, "Image", "");
1803         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_tex_image_update");
1804
1805         RNA_def_struct_sdna_from(srna, "NodeTexImage", "storage");
1806         def_sh_tex(srna);
1807
1808         prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
1809         RNA_def_property_enum_items(prop, prop_color_space_items);
1810         RNA_def_property_ui_text(prop, "Color Space", "Image file color space");
1811         RNA_def_property_update(prop, 0, "rna_Node_update");
1812
1813         prop = RNA_def_property(srna, "projection", PROP_ENUM, PROP_NONE);
1814         RNA_def_property_enum_items(prop, prop_projection_items);
1815         RNA_def_property_ui_text(prop, "Projection", "Method to project 2D image on object with a 3D texture vector");
1816         RNA_def_property_update(prop, 0, "rna_Node_update");
1817
1818         prop = RNA_def_property(srna, "projection_blend", PROP_FLOAT, PROP_FACTOR);
1819         RNA_def_property_ui_text(prop, "Projection Blend", "For box projection, amount of blend to use between sides");
1820         RNA_def_property_update(prop, 0, "rna_Node_update");
1821
1822         prop = RNA_def_property(srna, "image_user", PROP_POINTER, PROP_NONE);
1823         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1824         RNA_def_property_pointer_sdna(prop, NULL, "iuser");
1825         RNA_def_property_ui_text(prop, "Image User",
1826                                  "Parameters defining which layer, pass and frame of the image is displayed");
1827         RNA_def_property_update(prop, 0, "rna_Node_update");
1828 }
1829
1830 static void def_sh_tex_gradient(StructRNA *srna)
1831 {
1832         static EnumPropertyItem prop_gradient_type[] = {
1833                 {SHD_BLEND_LINEAR, "LINEAR", 0, "Linear", "Create a linear progression"},
1834                 {SHD_BLEND_QUADRATIC, "QUADRATIC", 0, "Quadratic", "Create a quadratic progression"},
1835                 {SHD_BLEND_EASING, "EASING", 0, "Easing", "Create a progression easing from one step to the next"},
1836                 {SHD_BLEND_DIAGONAL, "DIAGONAL", 0, "Diagonal", "Create a diagonal progression"},
1837                 {SHD_BLEND_SPHERICAL, "SPHERICAL", 0, "Spherical", "Create a spherical progression"},
1838                 {SHD_BLEND_QUADRATIC_SPHERE, "QUADRATIC_SPHERE", 0, "Quadratic sphere",
1839                                              "Create a quadratic progression in the shape of a sphere"},
1840                 {SHD_BLEND_RADIAL, "RADIAL", 0, "Radial", "Create a radial progression"},
1841                 {0, NULL, 0, NULL, NULL}
1842         };
1843
1844         PropertyRNA *prop;
1845         
1846         RNA_def_struct_sdna_from(srna, "NodeTexGradient", "storage");
1847         def_sh_tex(srna);
1848
1849         prop = RNA_def_property(srna, "gradient_type", PROP_ENUM, PROP_NONE);
1850         RNA_def_property_enum_items(prop, prop_gradient_type);
1851         RNA_def_property_ui_text(prop, "Gradient Type", "Style of the color blending");
1852         RNA_def_property_update(prop, 0, "rna_Node_update");
1853 }
1854
1855 static void def_sh_tex_noise(StructRNA *srna)
1856 {
1857         RNA_def_struct_sdna_from(srna, "NodeTexNoise", "storage");
1858         def_sh_tex(srna);
1859 }
1860
1861 static void def_sh_tex_checker(StructRNA *srna)
1862 {
1863         RNA_def_struct_sdna_from(srna, "NodeTexChecker", "storage");
1864         def_sh_tex(srna);
1865 }
1866
1867 static void def_sh_tex_brick(StructRNA *srna)
1868 {
1869         PropertyRNA *prop;
1870         
1871         RNA_def_struct_sdna_from(srna, "NodeTexBrick", "storage");
1872         def_sh_tex(srna);
1873         
1874         prop = RNA_def_property(srna, "offset_frequency", PROP_INT, PROP_NONE);
1875         RNA_def_property_int_sdna(prop, NULL, "offset_freq");
1876         RNA_def_property_int_default(prop, 2);
1877         RNA_def_property_range(prop, 1, 99);
1878         RNA_def_property_ui_text(prop, "Offset Frequency", "");
1879         RNA_def_property_update(prop, 0, "rna_Node_update");
1880         
1881         prop = RNA_def_property(srna, "squash_frequency", PROP_INT, PROP_NONE);
1882         RNA_def_property_int_sdna(prop, NULL, "squash_freq");
1883         RNA_def_property_int_default(prop, 2);
1884         RNA_def_property_range(prop, 1, 99);
1885         RNA_def_property_ui_text(prop, "Squash Frequency", "");
1886         RNA_def_property_update(prop, 0, "rna_Node_update");
1887         
1888         prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
1889         RNA_def_property_float_sdna(prop, NULL, "offset");
1890         RNA_def_property_float_default(prop, 0.5f);
1891         RNA_def_property_range(prop, 0.0f, 1.0f);
1892         RNA_def_property_ui_text(prop, "Offset Amount", "");
1893         RNA_def_property_update(prop, 0, "rna_Node_update");
1894         
1895         prop = RNA_def_property(srna, "squash", PROP_FLOAT, PROP_NONE);
1896         RNA_def_property_float_sdna(prop, NULL, "squash");
1897         RNA_def_property_float_default(prop, 1.0f);
1898         RNA_def_property_range(prop, 0.0f, 99.0f);
1899         RNA_def_property_ui_text(prop, "Squash Amount", "");
1900         RNA_def_property_update(prop, 0, "rna_Node_update");
1901         
1902 }
1903
1904 static void def_sh_tex_magic(StructRNA *srna)
1905 {
1906         PropertyRNA *prop;
1907         
1908         RNA_def_struct_sdna_from(srna, "NodeTexMagic", "storage");
1909         def_sh_tex(srna);
1910
1911         prop = RNA_def_property(srna, "turbulence_depth", PROP_INT, PROP_NONE);
1912         RNA_def_property_int_sdna(prop, NULL, "depth");
1913         RNA_def_property_range(prop, 0, 10);
1914         RNA_def_property_ui_text(prop, "Depth", "Level of detail in the added turbulent noise");
1915         RNA_def_property_update(prop, 0, "rna_Node_update");
1916 }
1917
1918 static void def_sh_tex_musgrave(StructRNA *srna)
1919 {
1920         static EnumPropertyItem prop_musgrave_type[] = {
1921                 {SHD_MUSGRAVE_MULTIFRACTAL, "MULTIFRACTAL", 0, "Multifractal", ""},
1922                 {SHD_MUSGRAVE_RIDGED_MULTIFRACTAL, "RIDGED_MULTIFRACTAL", 0, "Ridged Multifractal", ""},
1923                 {SHD_MUSGRAVE_HYBRID_MULTIFRACTAL, "HYBRID_MULTIFRACTAL", 0, "Hybrid Multifractal", ""},
1924                 {SHD_MUSGRAVE_FBM, "FBM", 0, "fBM", ""},
1925                 {SHD_MUSGRAVE_HETERO_TERRAIN, "HETERO_TERRAIN", 0, "Hetero Terrain", ""},
1926                 {0, NULL, 0, NULL, NULL}
1927         };
1928
1929         PropertyRNA *prop;
1930         
1931         RNA_def_struct_sdna_from(srna, "NodeTexMusgrave", "storage");
1932         def_sh_tex(srna);
1933
1934         prop = RNA_def_property(srna, "musgrave_type", PROP_ENUM, PROP_NONE);
1935         RNA_def_property_enum_sdna(prop, NULL, "musgrave_type");
1936         RNA_def_property_enum_items(prop, prop_musgrave_type);
1937         RNA_def_property_ui_text(prop, "Type", "");
1938         RNA_def_property_update(prop, 0, "rna_Node_update");
1939 }
1940
1941 static void def_sh_tex_voronoi(StructRNA *srna)
1942 {
1943         static EnumPropertyItem prop_coloring_items[] = {
1944                 {SHD_VORONOI_INTENSITY, "INTENSITY", 0, "Intensity", "Only calculate intensity"},
1945                 {SHD_VORONOI_CELLS, "CELLS", 0, "Cells", "Color cells by position"},
1946                 {0, NULL, 0, NULL, NULL}
1947         };
1948
1949         PropertyRNA *prop;
1950         
1951         RNA_def_struct_sdna_from(srna, "NodeTexVoronoi", "storage");
1952         def_sh_tex(srna);
1953
1954         prop = RNA_def_property(srna, "coloring", PROP_ENUM, PROP_NONE);
1955         RNA_def_property_enum_sdna(prop, NULL, "coloring");
1956         RNA_def_property_enum_items(prop, prop_coloring_items);
1957         RNA_def_property_ui_text(prop, "Coloring", "");
1958         RNA_def_property_update(prop, 0, "rna_Node_update");
1959 }
1960
1961 static void def_sh_tex_wave(StructRNA *srna)
1962 {
1963         static EnumPropertyItem prop_wave_type_items[] = {
1964                 {SHD_WAVE_BANDS, "BANDS", 0, "Bands", "Use standard wave texture in bands"},
1965                 {SHD_WAVE_RINGS, "RINGS", 0, "Rings", "Use wave texture in rings"},
1966                 {0, NULL, 0, NULL, NULL}
1967         };
1968
1969         PropertyRNA *prop;
1970         
1971         RNA_def_struct_sdna_from(srna, "NodeTexWave", "storage");
1972         def_sh_tex(srna);
1973
1974         prop = RNA_def_property(srna, "wave_type", PROP_ENUM, PROP_NONE);
1975         RNA_def_property_enum_sdna(prop, NULL, "wave_type");
1976         RNA_def_property_enum_items(prop, prop_wave_type_items);
1977         RNA_def_property_ui_text(prop, "Wave Type", "");
1978         RNA_def_property_update(prop, 0, "rna_Node_update");
1979 }
1980
1981 static void def_sh_tex_coord(StructRNA *srna)
1982 {
1983         PropertyRNA *prop;
1984         
1985         prop = RNA_def_property(srna, "from_dupli", PROP_BOOLEAN, PROP_NONE);
1986         RNA_def_property_boolean_sdna(prop, NULL, "custom1", 1);
1987         RNA_def_property_ui_text(prop, "From Dupli", "Use the parent of the dupli object if possible");
1988         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
1989 }
1990
1991 static void def_glossy(StructRNA *srna)
1992 {
1993         PropertyRNA *prop;
1994         
1995         prop = RNA_def_property(srna, "distribution", PROP_ENUM, PROP_NONE);
1996         RNA_def_property_enum_sdna(prop, NULL, "custom1");
1997         RNA_def_property_enum_items(prop, node_glossy_items);
1998         RNA_def_property_ui_text(prop, "Distribution", "");
1999         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2000 }
2001
2002 static void def_sh_normal_map(StructRNA *srna)
2003 {
2004         static EnumPropertyItem prop_space_items[] = {
2005                 {SHD_NORMAL_MAP_TANGENT, "TANGENT", 0, "Tangent Space", "Tangent space normal mapping"},
2006                 {SHD_NORMAL_MAP_OBJECT, "OBJECT", 0, "Object Space", "Object space normal mapping"},
2007                 {SHD_NORMAL_MAP_WORLD, "WORLD", 0, "World Space", "World space normal mapping"},
2008                 {0, NULL, 0, NULL, NULL}
2009         };
2010
2011         PropertyRNA *prop;
2012
2013         RNA_def_struct_sdna_from(srna, "NodeShaderNormalMap", "storage");
2014
2015         prop = RNA_def_property(srna, "space", PROP_ENUM, PROP_NONE);
2016         RNA_def_property_enum_items(prop, prop_space_items);
2017         RNA_def_property_ui_text(prop, "Space", "Space of the input normal");
2018         RNA_def_property_update(prop, 0, "rna_Node_update");
2019
2020         prop = RNA_def_property(srna, "uv_map", PROP_STRING, PROP_NONE);
2021         RNA_def_property_ui_text(prop, "UV Map", "UV Map for tangent space maps");
2022         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2023
2024         RNA_def_struct_sdna_from(srna, "bNode", NULL);
2025 }
2026
2027 static void def_sh_tangent(StructRNA *srna)
2028 {
2029         static EnumPropertyItem prop_direction_type_items[] = {
2030                 {SHD_TANGENT_RADIAL, "RADIAL", 0, "Radial", "Radial tangent around the X, Y or Z axis"},
2031                 {SHD_TANGENT_UVMAP, "UV_MAP", 0, "UV Map", "Tangent from UV map"},
2032                 {0, NULL, 0, NULL, NULL}
2033         };
2034
2035         static EnumPropertyItem prop_axis_items[] = {
2036                 {SHD_TANGENT_AXIS_X, "X", 0, "X", "X axis"},
2037                 {SHD_TANGENT_AXIS_Y, "Y", 0, "Y", "Y axis"},
2038                 {SHD_TANGENT_AXIS_Z, "Z", 0, "Z", "Z axis"},
2039                 {0, NULL, 0, NULL, NULL}
2040         };
2041
2042         PropertyRNA *prop;
2043
2044         RNA_def_struct_sdna_from(srna, "NodeShaderTangent", "storage");
2045
2046         prop = RNA_def_property(srna, "direction_type", PROP_ENUM, PROP_NONE);
2047         RNA_def_property_enum_items(prop, prop_direction_type_items);
2048         RNA_def_property_ui_text(prop, "Direction", "Method to use for the tangent");
2049         RNA_def_property_update(prop, 0, "rna_Node_update");
2050
2051         prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
2052         RNA_def_property_enum_items(prop, prop_axis_items);
2053         RNA_def_property_ui_text(prop, "Axis", "Axis for radial tangents");
2054         RNA_def_property_update(prop, 0, "rna_Node_update");
2055
2056         prop = RNA_def_property(srna, "uv_map", PROP_STRING, PROP_NONE);
2057         RNA_def_property_ui_text(prop, "UV Map", "UV Map for tangent generated from UV");
2058         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2059
2060         RNA_def_struct_sdna_from(srna, "bNode", NULL);
2061 }
2062
2063 static void def_sh_script(StructRNA *srna)
2064 {
2065         FunctionRNA *func;
2066         PropertyRNA *prop, *parm;
2067
2068         prop = RNA_def_property(srna, "script", PROP_POINTER, PROP_NONE);
2069         RNA_def_property_pointer_sdna(prop, NULL, "id");
2070         RNA_def_property_struct_type(prop, "Text");
2071         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
2072         RNA_def_property_ui_text(prop, "Script", "Internal shader script to define the shader");
2073         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNodeScript_update");
2074         
2075         RNA_def_struct_sdna_from(srna, "NodeShaderScript", "storage");
2076         RNA_def_struct_idprops_func(srna, "rna_ShaderNodeScript_idprops");
2077         
2078         prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
2079         RNA_def_property_ui_text(prop, "File Path", "Shader script path");
2080         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNodeScript_update");
2081
2082         prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
2083         RNA_def_property_enum_funcs(prop, NULL, "rna_ShaderNodeScript_mode_set", NULL);
2084         RNA_def_property_enum_items(prop, node_script_mode_items);
2085         RNA_def_property_ui_text(prop, "Script Source", "");
2086         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2087
2088         prop = RNA_def_property(srna, "use_auto_update", PROP_BOOLEAN, PROP_NONE);
2089         RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_SCRIPT_AUTO_UPDATE);
2090         RNA_def_property_ui_text(prop, "Auto Update",
2091                                  "Automatically update the shader when the .osl file changes (external scripts only)");
2092         
2093         prop = RNA_def_property(srna, "bytecode", PROP_STRING, PROP_NONE);
2094         RNA_def_property_string_funcs(prop, "rna_ShaderNodeScript_bytecode_get", "rna_ShaderNodeScript_bytecode_length",
2095                                       "rna_ShaderNodeScript_bytecode_set");
2096         RNA_def_property_ui_text(prop, "Bytecode", "Compile bytecode for shader script node");
2097         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2098
2099         prop = RNA_def_property(srna, "bytecode_hash", PROP_STRING, PROP_NONE);
2100         RNA_def_property_ui_text(prop, "Bytecode Hash", "Hash of compile bytecode, for quick equality checking");
2101         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2102
2103         /* needs to be reset to avoid bad pointer type in API functions below */
2104         RNA_def_struct_sdna_from(srna, "bNode", NULL);
2105         
2106         /* API functions */
2107         
2108         func = RNA_def_function(srna, "find_socket", "rna_ShaderNodeScript_find_socket");
2109         RNA_def_function_ui_description(func, "Find a socket by name");
2110         parm = RNA_def_string(func, "name", "", 0, "Socket name", "");
2111         RNA_def_property_flag(parm, PROP_REQUIRED);
2112         /*parm =*/ RNA_def_boolean(func, "is_output", FALSE, "Output", "Whether the socket is an output");
2113         parm = RNA_def_pointer(func, "result", "NodeSocket", "", "");
2114         RNA_def_function_return(func, parm);
2115         
2116         func = RNA_def_function(srna, "add_socket", "rna_ShaderNodeScript_add_socket");
2117         RNA_def_function_ui_description(func, "Add a socket socket");
2118         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
2119         parm = RNA_def_string(func, "name", "", 0, "Name", "");
2120         RNA_def_property_flag(parm, PROP_REQUIRED);
2121         parm = RNA_def_enum(func, "type", node_socket_type_items, SOCK_FLOAT, "Type", "");
2122         RNA_def_property_flag(parm, PROP_REQUIRED);
2123         /*parm =*/ RNA_def_boolean(func, "is_output", FALSE, "Output", "Whether the socket is an output");
2124         parm = RNA_def_pointer(func, "result", "NodeSocket", "", "");
2125         RNA_def_function_return(func, parm);
2126         
2127         func = RNA_def_function(srna, "remove_socket", "rna_ShaderNodeScript_remove_socket");
2128         RNA_def_function_ui_description(func, "Remove a socket socket");
2129         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
2130         parm = RNA_def_pointer(func, "sock", "NodeSocket", "Socket", "");
2131         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
2132 }
2133
2134 /* -- Compositor Nodes ------------------------------------------------------ */
2135
2136 static void def_cmp_alpha_over(StructRNA *srna)
2137 {
2138         PropertyRNA *prop;
2139         
2140         /* XXX: Tooltip */
2141         prop = RNA_def_property(srna, "use_premultiply", PROP_BOOLEAN, PROP_NONE);
2142         RNA_def_property_boolean_sdna(prop, NULL, "custom1", 1);
2143         RNA_def_property_ui_text(prop, "Convert Premul", "");
2144         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2145         
2146         RNA_def_struct_sdna_from(srna, "NodeTwoFloats", "storage");
2147         
2148         prop = RNA_def_property(srna, "premul", PROP_FLOAT, PROP_NONE);
2149         RNA_def_property_float_sdna(prop, NULL, "x");
2150         RNA_def_property_range(prop, 0.0f, 1.0f);
2151         RNA_def_property_ui_text(prop, "Premul", "Mix Factor");
2152         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2153 }
2154
2155 static void def_cmp_hue_saturation(StructRNA *srna)
2156 {
2157         PropertyRNA *prop;
2158
2159         RNA_def_struct_sdna_from(srna, "NodeHueSat", "storage");
2160         
2161         prop = RNA_def_property(srna, "color_hue", PROP_FLOAT, PROP_NONE);
2162         RNA_def_property_float_sdna(prop, NULL, "hue");
2163         RNA_def_property_range(prop, 0.0f, 1.0f);
2164         RNA_def_property_ui_text(prop, "Hue", "");
2165         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2166         
2167         prop = RNA_def_property(srna, "color_saturation", PROP_FLOAT, PROP_NONE);
2168         RNA_def_property_float_sdna(prop, NULL, "sat");
2169         RNA_def_property_range(prop, 0.0f, 2.0f);
2170         RNA_def_property_ui_text(prop, "Saturation", "");
2171         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2172         
2173         prop = RNA_def_property(srna, "color_value", PROP_FLOAT, PROP_NONE);
2174         RNA_def_property_float_sdna(prop, NULL, "val");
2175         RNA_def_property_range(prop, 0.0f, 2.0f);
2176         RNA_def_property_ui_text(prop, "Value", "");
2177         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2178 }
2179
2180 static void def_cmp_blur(StructRNA *srna)
2181 {
2182         PropertyRNA *prop;
2183         
2184         static EnumPropertyItem filter_type_items[] = {
2185                 {R_FILTER_BOX,        "FLAT",       0, "Flat",          ""},
2186                 {R_FILTER_TENT,       "TENT",       0, "Tent",          ""},
2187                 {R_FILTER_QUAD,       "QUAD",       0, "Quadratic",     ""},
2188                 {R_FILTER_CUBIC,      "CUBIC",      0, "Cubic",         ""},
2189                 {R_FILTER_GAUSS,      "GAUSS",      0, "Gaussian",      ""},
2190                 {R_FILTER_FAST_GAUSS, "FAST_GAUSS", 0, "Fast Gaussian", ""},
2191                 {R_FILTER_CATROM,     "CATROM",     0, "Catrom",        ""},
2192                 {R_FILTER_MITCH,      "MITCH",      0, "Mitch",         ""},
2193                 {0, NULL, 0, NULL, NULL}
2194         };
2195
2196         static EnumPropertyItem aspect_correction_type_items[] = {
2197                 {CMP_NODE_BLUR_ASPECT_NONE, "NONE", 0,  "None", ""},
2198                 {CMP_NODE_BLUR_ASPECT_Y,    "Y",    0,  "Y",    ""},
2199                 {CMP_NODE_BLUR_ASPECT_X,    "X",    0,  "X",    ""},
2200                 {0, NULL, 0, NULL, NULL}
2201         };
2202
2203         /* duplicated in def_cmp_bokehblur */
2204         prop = RNA_def_property(srna, "use_variable_size", PROP_BOOLEAN, PROP_NONE);
2205         RNA_def_property_boolean_sdna(prop, NULL, "custom1", CMP_NODEFLAG_BLUR_VARIABLE_SIZE);
2206         RNA_def_property_ui_text(prop, "Variable Size", "Support variable blur per-pixel when using an image for size input");
2207         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2208
2209         RNA_def_struct_sdna_from(srna, "NodeBlurData", "storage");
2210         
2211         prop = RNA_def_property(srna, "size_x", PROP_INT, PROP_NONE);
2212         RNA_def_property_int_sdna(prop, NULL, "sizex");
2213         RNA_def_property_range(prop, 0, 2048);
2214         RNA_def_property_ui_text(prop, "Size X", "");
2215         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2216         
2217         prop = RNA_def_property(srna, "size_y", PROP_INT, PROP_NONE);
2218         RNA_def_property_int_sdna(prop, NULL, "sizey");
2219         RNA_def_property_range(prop, 0, 2048);
2220         RNA_def_property_ui_text(prop, "Size Y", "");
2221         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2222
2223         prop = RNA_def_property(srna, "use_relative", PROP_BOOLEAN, PROP_NONE);
2224         RNA_def_property_boolean_sdna(prop, NULL, "relative", 1);
2225         RNA_def_property_ui_text(prop, "Relative", "Use relative (percent) values to define blur radius");
2226         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2227         
2228         prop = RNA_def_property(srna, "aspect_correction", PROP_ENUM, PROP_NONE);
2229         RNA_def_property_enum_sdna(prop, NULL, "aspect");
2230         RNA_def_property_enum_items(prop, aspect_correction_type_items);
2231         RNA_def_property_ui_text(prop, "Aspect Correction", "Type of aspect correction to use");
2232         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2233
2234         prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
2235         RNA_def_property_float_sdna(prop, NULL, "fac");
2236         RNA_def_property_range(prop, 0.0f, 2.0f);
2237         RNA_def_property_ui_text(prop, "Factor", "");
2238         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2239         
2240         prop = RNA_def_property(srna, "factor_x", PROP_FLOAT, PROP_PERCENTAGE);
2241         RNA_def_property_float_sdna(prop, NULL, "percentx");
2242         RNA_def_property_range(prop, 0.0f, 100.0f);
2243         RNA_def_property_ui_text(prop, "Relative Size X", "");
2244         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2245         
2246         prop = RNA_def_property(srna, "factor_y", PROP_FLOAT, PROP_PERCENTAGE);
2247         RNA_def_property_float_sdna(prop, NULL, "percenty");
2248         RNA_def_property_range(prop, 0.0f, 100.0f);
2249         RNA_def_property_ui_text(prop, "Relative Size Y", "");
2250         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2251         
2252         prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
2253         RNA_def_property_enum_sdna(prop, NULL, "filtertype");
2254         RNA_def_property_enum_items(prop, filter_type_items);
2255         RNA_def_property_ui_text(prop, "Filter Type", "");
2256         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2257         
2258         prop = RNA_def_property(srna, "use_bokeh", PROP_BOOLEAN, PROP_NONE);
2259         RNA_def_property_boolean_sdna(prop, NULL, "bokeh", 1);
2260         RNA_def_property_ui_text(prop, "Bokeh", "Use circular filter (slower)");
2261         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2262         
2263         prop = RNA_def_property(srna, "use_gamma_correction", PROP_BOOLEAN, PROP_NONE);
2264         RNA_def_property_boolean_sdna(prop, NULL, "gamma", 1);
2265         RNA_def_property_ui_text(prop, "Gamma", "Apply filter on gamma corrected values");
2266         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2267 }
2268
2269 static void def_cmp_filter(StructRNA *srna)
2270 {
2271         PropertyRNA *prop;
2272
2273         prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
2274         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2275         RNA_def_property_enum_items(prop, node_filter_items);
2276         RNA_def_property_ui_text(prop, "Filter Type", "");
2277         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2278 }
2279
2280 static void def_cmp_map_value(StructRNA *srna)
2281 {
2282         PropertyRNA *prop;
2283         
2284         RNA_def_struct_sdna_from(srna, "TexMapping", "storage");
2285         
2286         prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
2287         RNA_def_property_float_sdna(prop, NULL, "loc");
2288         RNA_def_property_array(prop, 1);
2289         RNA_def_property_range(prop, -1000.0f, 1000.0f);
2290         RNA_def_property_ui_text(prop, "Offset", "");
2291         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2292         
2293         prop = RNA_def_property(srna, "size", PROP_FLOAT, PROP_NONE);
2294         RNA_def_property_float_sdna(prop, NULL, "size");
2295         RNA_def_property_array(prop, 1);
2296         RNA_def_property_range(prop, -1000.0f, 1000.0f);
2297         RNA_def_property_ui_text(prop, "Size", "");
2298         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2299         
2300         prop = RNA_def_property(srna, "use_min", PROP_BOOLEAN, PROP_NONE);
2301         RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MIN);
2302         RNA_def_property_ui_text(prop, "Use Minimum", "");
2303         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2304         
2305         prop = RNA_def_property(srna, "use_max", PROP_BOOLEAN, PROP_NONE);
2306         RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MAX);
2307         RNA_def_property_ui_text(prop, "Use Maximum", "");
2308         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2309         
2310         prop = RNA_def_property(srna, "min", PROP_FLOAT, PROP_NONE);
2311         RNA_def_property_float_sdna(prop, NULL, "min");
2312         RNA_def_property_array(prop, 1);
2313         RNA_def_property_range(prop, -1000.0f, 1000.0f);
2314         RNA_def_property_ui_text(prop, "Minimum", "");
2315         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2316         
2317         prop = RNA_def_property(srna, "max", PROP_FLOAT, PROP_NONE);
2318         RNA_def_property_float_sdna(prop, NULL, "max");
2319         RNA_def_property_array(prop, 1);
2320         RNA_def_property_range(prop, -1000.0f, 1000.0f);
2321         RNA_def_property_ui_text(prop, "Maximum", "");
2322         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2323 }
2324
2325 static void def_cmp_map_range(StructRNA *srna)
2326 {
2327         PropertyRNA *prop;
2328         
2329         prop = RNA_def_property(srna, "use_clamp", PROP_BOOLEAN, PROP_NONE);
2330         RNA_def_property_boolean_sdna(prop, NULL, "custom1", 1);
2331         RNA_def_property_ui_text(prop, "Clamp", "Clamp result of the node to 0..1 range");
2332         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2333 }
2334
2335 static void def_cmp_vector_blur(StructRNA *srna)
2336 {
2337         PropertyRNA *prop;
2338         
2339         RNA_def_struct_sdna_from(srna, "NodeBlurData", "storage");
2340         
2341         prop = RNA_def_property(srna, "samples", PROP_INT, PROP_NONE);
2342         RNA_def_property_int_sdna(prop, NULL, "samples");
2343         RNA_def_property_range(prop, 1, 256);
2344         RNA_def_property_ui_text(prop, "Samples", "");
2345         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2346         
2347         prop = RNA_def_property(srna, "speed_min", PROP_INT, PROP_NONE);
2348         RNA_def_property_int_sdna(prop, NULL, "minspeed");
2349         RNA_def_property_range(prop, 0, 1024);
2350         RNA_def_property_ui_text(prop, "Min Speed",
2351                                  "Minimum speed for a pixel to be blurred (used to separate background from foreground)");
2352         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2353                 
2354         prop = RNA_def_property(srna, "speed_max", PROP_INT, PROP_NONE);
2355         RNA_def_property_int_sdna(prop, NULL, "maxspeed");
2356         RNA_def_property_range(prop, 0, 1024);
2357         RNA_def_property_ui_text(prop, "Max Speed", "Maximum speed, or zero for none");
2358         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2359         
2360         prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
2361         RNA_def_property_float_sdna(prop, NULL, "fac");
2362         RNA_def_property_range(prop, 0.0, 20.0);
2363         RNA_def_property_ui_range(prop, 0.0, 2.0, 1.0, 2);
2364         RNA_def_property_ui_text(prop, "Blur Factor",
2365                                  "Scaling factor for motion vectors (actually, 'shutter speed', in frames)");
2366         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2367         
2368         prop = RNA_def_property(srna, "use_curved", PROP_BOOLEAN, PROP_NONE);
2369         RNA_def_property_boolean_sdna(prop, NULL, "curved", 1);
2370         RNA_def_property_ui_text(prop, "Curved", "Interpolate between frames in a Bezier curve, rather than linearly");
2371         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2372 }
2373
2374 static void def_cmp_levels(StructRNA *srna)
2375 {
2376         PropertyRNA *prop;
2377         
2378         static EnumPropertyItem channel_items[] = {
2379                 {1, "COMBINED_RGB", 0, "C", "Combined RGB"},
2380                 {2, "RED", 0, "R", "Red Channel"},
2381                 {3, "GREEN", 0, "G", "Green Channel"},
2382                 {4, "BLUE", 0, "B", "Blue Channel"},
2383                 {5, "LUMINANCE", 0, "L", "Luminance Channel"},
2384                 {0, NULL, 0, NULL, NULL}
2385         };
2386         
2387         prop = RNA_def_property(srna, "channel", PROP_ENUM, PROP_NONE);
2388         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2389         RNA_def_property_enum_items(prop, channel_items);
2390         RNA_def_property_ui_text(prop, "Channel", "");
2391         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2392 }
2393
2394 static void def_node_image_user(StructRNA *srna)
2395 {
2396         PropertyRNA *prop;
2397
2398         prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_NONE);
2399         RNA_def_property_int_sdna(prop, NULL, "frames");
2400         RNA_def_property_range(prop, 0, MAXFRAMEF);
2401         RNA_def_property_ui_text(prop, "Frames", "Number of images of a movie to use"); /* copied from the rna_image.c */
2402         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2403         
2404         prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_NONE);
2405         RNA_def_property_int_sdna(prop, NULL, "sfra");
2406         RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
2407         /* copied from the rna_image.c */
2408         RNA_def_property_ui_text(prop, "Start Frame",
2409                                  "Global starting frame of the movie/sequence, assuming first picture has a #1");
2410         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2411         
2412         prop = RNA_def_property(srna, "frame_offset", PROP_INT, PROP_NONE);
2413         RNA_def_property_int_sdna(prop, NULL, "offset");
2414         RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
2415         /* copied from the rna_image.c */
2416         RNA_def_property_ui_text(prop, "Offset", "Offset the number of the frame to use in the animation");
2417         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2418         
2419         prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
2420         RNA_def_property_boolean_sdna(prop, NULL, "cycl", 1);
2421         RNA_def_property_ui_text(prop, "Cyclic", "Cycle the images in the movie"); /* copied from the rna_image.c */
2422         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2423         
2424         prop = RNA_def_property(srna, "use_auto_refresh", PROP_BOOLEAN, PROP_NONE);
2425         RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_ANIM_ALWAYS);
2426         /* copied from the rna_image.c */
2427         RNA_def_property_ui_text(prop, "Auto-Refresh", "Always refresh image on frame changes");
2428         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2429
2430         prop = RNA_def_property(srna, "layer", PROP_ENUM, PROP_NONE);
2431         RNA_def_property_enum_sdna(prop, NULL, "layer");
2432         RNA_def_property_enum_items(prop, prop_image_layer_items);
2433         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Node_image_layer_itemf");
2434         RNA_def_property_ui_text(prop, "Layer", "");
2435         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_image_layer_update");
2436 }
2437
2438 static void def_cmp_image(StructRNA *srna)
2439 {
2440         PropertyRNA *prop;
2441         
2442 #if 0
2443         static EnumPropertyItem type_items[] = {
2444                 {IMA_SRC_FILE,      "IMAGE",     0, "Image",     ""},
2445                 {IMA_SRC_MOVIE,     "MOVIE",     "Movie",     ""},
2446                 {IMA_SRC_SEQUENCE,  "SEQUENCE",  "Sequence",  ""},
2447                 {IMA_SRC_GENERATED, "GENERATED", "Generated", ""},
2448                 {0, NULL, 0, NULL, NULL}
2449         };
2450 #endif
2451         
2452         prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
2453         RNA_def_property_pointer_sdna(prop, NULL, "id");
2454         RNA_def_property_struct_type(prop, "Image");
2455         RNA_def_property_flag(prop, PROP_EDITABLE);
2456         RNA_def_property_ui_text(prop, "Image", "");
2457         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Image_Node_update_id");
2458
2459         prop = RNA_def_property(srna, "use_straight_alpha_output", PROP_BOOLEAN, PROP_NONE);
2460         RNA_def_property_boolean_sdna(prop, NULL, "custom1", CMP_NODE_IMAGE_USE_STRAIGHT_OUTPUT);
2461         RNA_def_property_ui_text(prop, "Straight Alpha Output", "Put Node output buffer to straight alpha instead of premultiplied");
2462         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2463
2464         /* NB: image user properties used in the UI are redefined in def_node_image_user,
2465          * to trigger correct updates of the node editor. RNA design problem that prevents
2466          * updates from nested structs ...
2467          */
2468         RNA_def_struct_sdna_from(srna, "ImageUser", "storage");
2469         def_node_image_user(srna);
2470 }
2471
2472 static void def_cmp_render_layers(StructRNA *srna)
2473 {
2474         PropertyRNA *prop;
2475         
2476         prop = RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE);
2477         RNA_def_property_pointer_sdna(prop, NULL, "id");
2478         RNA_def_property_pointer_funcs(prop, NULL, "rna_Node_scene_set", NULL, NULL);
2479         RNA_def_property_struct_type(prop, "Scene");
2480         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
2481         RNA_def_property_ui_text(prop, "Scene", "");
2482         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2483         
2484         prop = RNA_def_property(srna, "layer", PROP_ENUM, PROP_NONE);
2485         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2486         RNA_def_property_enum_items(prop, prop_scene_layer_items);
2487         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Node_scene_layer_itemf");
2488         RNA_def_property_ui_text(prop, "Layer", "");
2489         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2490 }
2491
2492 static void rna_def_cmp_output_file_slot_file(BlenderRNA *brna)
2493 {
2494         StructRNA *srna;
2495         PropertyRNA *prop;
2496         
2497         srna = RNA_def_struct(brna, "NodeOutputFileSlotFile", NULL);
2498         RNA_def_struct_sdna(srna, "NodeImageMultiFileSocket");
2499         RNA_def_struct_ui_text(srna, "Output File Slot", "Single layer file slot of the file output node");
2500         
2501         prop = RNA_def_property(srna, "use_node_format", PROP_BOOLEAN, PROP_NONE);
2502         RNA_def_property_boolean_sdna(prop, NULL, "use_node_format", 1);
2503         RNA_def_property_ui_text(prop, "Use Node Format", "");
2504         RNA_def_property_update(prop, NC_NODE | NA_EDITED, NULL);
2505         
2506         prop = RNA_def_property(srna, "format", PROP_POINTER, PROP_NONE);
2507         RNA_def_property_struct_type(prop, "ImageFormatSettings");
2508         
2509         prop = RNA_def_property(srna, "path", PROP_STRING, PROP_FILEPATH);
2510         RNA_def_property_string_sdna(prop, NULL, "path");
2511         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_NodeOutputFileSlotFile_path_set");
2512         RNA_def_struct_name_property(srna, prop);
2513         RNA_def_property_ui_text(prop, "Path", "Subpath used for this slot");
2514         RNA_def_property_update(prop, NC_NODE | NA_EDITED, NULL);
2515 }
2516 static void rna_def_cmp_output_file_slot_layer(BlenderRNA *brna)
2517 {
2518         StructRNA *srna;
2519         PropertyRNA *prop;
2520         
2521         srna = RNA_def_struct(brna, "NodeOutputFileSlotLayer", NULL);
2522         RNA_def_struct_sdna(srna, "NodeImageMultiFileSocket");
2523         RNA_def_struct_ui_text(srna, "Output File Layer Slot", "Multilayer slot of the file output node");
2524         
2525         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2526         RNA_def_property_string_sdna(prop, NULL, "layer");
2527         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_NodeOutputFileSlotLayer_name_set");
2528         RNA_def_struct_name_property(srna, prop);
2529         RNA_def_property_ui_text(prop, "Name", "OpenEXR layer name used for this slot");
2530         RNA_def_property_update(prop, NC_NODE | NA_EDITED, NULL);
2531 }
2532 static void def_cmp_output_file(StructRNA *srna)
2533 {
2534         PropertyRNA *prop;
2535         
2536         RNA_def_struct_sdna_from(srna, "NodeImageMultiFile", "storage");
2537         
2538         prop = RNA_def_property(srna, "base_path", PROP_STRING, PROP_FILEPATH);
2539         RNA_def_property_string_sdna(prop, NULL, "base_path");
2540         RNA_def_property_ui_text(prop, "Base Path", "Base output path for the image");
2541         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2542         
2543         prop = RNA_def_property(srna, "active_input_index", PROP_INT, PROP_NONE);
2544         RNA_def_property_int_sdna(prop, NULL, "active_input");
2545         RNA_def_property_ui_text(prop, "Active Input Index", "Active input index in details view list");
2546         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2547         
2548         prop = RNA_def_property(srna, "format", PROP_POINTER, PROP_NONE);
2549         RNA_def_property_struct_type(prop, "ImageFormatSettings");
2550         
2551         /* XXX using two different collections here for the same basic DNA list!
2552          * Details of the output slots depend on whether the node is in Multilayer EXR mode.
2553          */
2554         
2555         prop = RNA_def_property(srna, "file_slots", PROP_COLLECTION, PROP_NONE);
2556         RNA_def_property_collection_funcs(prop, "rna_NodeOutputFile_slots_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end",
2557                                           "rna_NodeOutputFile_slot_file_get", NULL, NULL, NULL, NULL);
2558         RNA_def_property_struct_type(prop, "NodeOutputFileSlotFile");
2559         RNA_def_property_ui_text(prop, "File Slots", "");
2560         
2561         prop = RNA_def_property(srna, "layer_slots", PROP_COLLECTION, PROP_NONE);
2562         RNA_def_property_collection_funcs(prop, "rna_NodeOutputFile_slots_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end",
2563                                           "rna_NodeOutputFile_slot_layer_get", NULL, NULL, NULL, NULL);
2564         RNA_def_property_struct_type(prop, "NodeOutputFileSlotLayer");
2565         RNA_def_property_ui_text(prop, "EXR Layer Slots", "");
2566 }
2567
2568 static void def_cmp_dilate_erode(StructRNA *srna)
2569 {
2570         PropertyRNA *prop;
2571
2572         static EnumPropertyItem mode_items[] = {
2573             {CMP_NODE_DILATEERODE_STEP,             "STEP",      0, "Step",      ""},
2574             {CMP_NODE_DILATEERODE_DISTANCE_THRESH,  "THRESHOLD", 0, "Threshold", ""},
2575             {CMP_NODE_DILATEERODE_DISTANCE,         "DISTANCE",  0, "Distance",  ""},
2576             {CMP_NODE_DILATEERODE_DISTANCE_FEATHER, "FEATHER",   0, "Feather",  ""},
2577             {0, NULL, 0, NULL, NULL}
2578         };
2579         
2580         prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
2581         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2582         RNA_def_property_enum_items(prop, mode_items);
2583         RNA_def_property_ui_text(prop, "Mode", "Growing/shrinking mode");
2584         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2585         
2586         prop = RNA_def_property(srna, "distance", PROP_INT, PROP_NONE);
2587         RNA_def_property_int_sdna(prop, NULL, "custom2");
2588         RNA_def_property_range(prop, -5000, 5000);
2589         RNA_def_property_ui_range(prop, -100, 100, 0, 0);
2590         RNA_def_property_ui_text(prop, "Distance", "Distance to grow/shrink (number of iterations)");
2591         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2592
2593         /* CMP_NODE_DILATEERODE_DISTANCE_THRESH only */
2594         prop = RNA_def_property(srna, "edge", PROP_FLOAT, PROP_NONE);
2595         RNA_def_property_float_sdna(prop, NULL, "custom3");
2596         RNA_def_property_range(prop, -100, 100);
2597         RNA_def_property_ui_text(prop, "Edge", "Edge to inset");
2598         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2599
2600         RNA_def_struct_sdna_from(srna, "NodeDilateErode", "storage");
2601
2602         /* CMP_NODE_DILATEERODE_DISTANCE_FEATHER only */
2603         prop = RNA_def_property(srna, "falloff", PROP_ENUM, PROP_NONE);
2604         RNA_def_property_enum_sdna(prop, NULL, "falloff");
2605         RNA_def_property_enum_items(prop, proportional_falloff_curve_only_items);
2606         RNA_def_property_ui_text(prop, "Falloff", "Falloff type the feather");
2607         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2608 }
2609
2610 static void def_cmp_inpaint(StructRNA *srna)
2611 {
2612         PropertyRNA *prop;
2613
2614 #if 0
2615         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
2616
2617         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2618         RNA_def_property_enum_items(prop, type_items);
2619         RNA_def_property_ui_text(prop, "Type", "Type of inpaint algorithm");
2620         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2621 #endif
2622         
2623         prop = RNA_def_property(srna, "distance", PROP_INT, PROP_NONE);
2624         RNA_def_property_int_sdna(prop, NULL, "custom2");
2625         RNA_def_property_range(prop, 1, 10000);
2626         RNA_def_property_ui_text(prop, "Distance", "Distance to inpaint (number of iterations)");
2627         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2628 }
2629
2630 static void def_cmp_despeckle(StructRNA *srna)
2631 {
2632         PropertyRNA *prop;
2633
2634         prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_NONE);
2635         RNA_def_property_float_sdna(prop, NULL, "custom3");
2636         RNA_def_property_range(prop, 0.0, 1.0f);
2637         RNA_def_property_ui_text(prop, "Threshold", "Threshold for detecting pixels to despeckle");
2638         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2639
2640         prop = RNA_def_property(srna, "threshold_neighbour", PROP_FLOAT, PROP_NONE);
2641         RNA_def_property_float_sdna(prop, NULL, "custom4");
2642         RNA_def_property_range(prop, 0.0, 1.0f);
2643         RNA_def_property_ui_text(prop, "Neighbor", "Threshold for the number of neighbor pixels that must match");
2644         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2645 }
2646
2647 static void def_cmp_scale(StructRNA *srna)
2648 {
2649         PropertyRNA *prop;
2650
2651         static EnumPropertyItem space_items[] = {
2652                 {CMP_SCALE_RELATIVE, "RELATIVE",   0, "Relative",   ""},
2653                 {CMP_SCALE_ABSOLUTE, "ABSOLUTE",   0, "Absolute",   ""},
2654                 {CMP_SCALE_SCENEPERCENT, "SCENE_SIZE", 0, "Scene Size", ""},
2655                 {CMP_SCALE_RENDERPERCENT, "RENDER_SIZE", 0, "Render Size", ""},
2656                 {0, NULL, 0, NULL, NULL}
2657         };
2658         
2659         /* matching bgpic_camera_frame_items[] */
2660         static const EnumPropertyItem space_frame_items[] = {
2661                 {0, "STRETCH", 0, "Stretch", ""},
2662                 {CMP_SCALE_RENDERSIZE_FRAME_ASPECT, "FIT", 0, "Fit", ""},
2663                 {CMP_SCALE_RENDERSIZE_FRAME_ASPECT | CMP_SCALE_RENDERSIZE_FRAME_CROP, "CROP", 0, "Crop", ""},
2664                 {0, NULL, 0, NULL, NULL}
2665         };
2666
2667         prop = RNA_def_property(srna, "space", PROP_ENUM, PROP_NONE);
2668         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2669         RNA_def_property_enum_items(prop, space_items);
2670         RNA_def_property_ui_text(prop, "Space", "Coordinate space to scale relative to");
2671         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2672
2673         /* expose 2 flags as a enum of 3 items */
2674         prop = RNA_def_property(srna, "frame_method", PROP_ENUM, PROP_NONE);
2675         RNA_def_property_enum_bitflag_sdna(prop, NULL, "custom2");
2676         RNA_def_property_enum_items(prop, space_frame_items);
2677         RNA_def_property_ui_text(prop, "Frame Method", "How the image fits in the camera frame");
2678         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2679
2680         prop = RNA_def_property(srna, "offset_x", PROP_FLOAT, PROP_NONE);
2681         RNA_def_property_float_sdna(prop, NULL, "custom3");
2682         RNA_def_property_ui_text(prop, "X Offset", "Offset image horizontally (factor of image size)");
2683         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2684
2685         prop = RNA_def_property(srna, "offset_y", PROP_FLOAT, PROP_NONE);
2686         RNA_def_property_float_sdna(prop, NULL, "custom4");
2687         RNA_def_property_ui_text(prop, "Y Offset", "Offset image vertically (factor of image size)");
2688         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2689 }
2690
2691 static void def_cmp_rotate(StructRNA *srna)
2692 {
2693         PropertyRNA *prop;
2694         
2695         prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
2696         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2697         RNA_def_property_enum_items(prop, node_sampler_type_items);
2698         RNA_def_property_ui_text(prop, "Filter", "Method to use to filter rotation");
2699         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2700 }
2701
2702 static void def_cmp_diff_matte(StructRNA *srna)
2703 {
2704         PropertyRNA *prop;
2705
2706         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
2707         
2708         prop = RNA_def_property(srna, "tolerance", PROP_FLOAT, PROP_NONE);
2709         RNA_def_property_float_sdna(prop, NULL, "t1");
2710         RNA_def_property_float_funcs(prop, NULL, "rna_difference_matte_t1_set", NULL);
2711         RNA_def_property_range(prop, 0.0f, 1.0f);
2712         RNA_def_property_ui_text(prop, "Tolerance", "Color distances below this threshold are keyed");
2713         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2714         
2715         prop = RNA_def_property(srna, "falloff", PROP_FLOAT, PROP_NONE);
2716         RNA_def_property_float_sdna(prop, NULL, "t2");
2717         RNA_def_property_float_funcs(prop, NULL, "rna_difference_matte_t2_set", NULL);
2718         RNA_def_property_range(prop, 0.0f, 1.0f);
2719         RNA_def_property_ui_text(prop, "Falloff", "Color distances below this additional threshold are partially keyed");
2720         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2721 }
2722
2723 static void def_cmp_color_matte(StructRNA *srna)
2724 {
2725         PropertyRNA *prop;
2726         
2727         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
2728
2729         prop = RNA_def_property(srna, "color_hue", PROP_FLOAT, PROP_NONE);
2730         RNA_def_property_float_sdna(prop, NULL, "t1");
2731         RNA_def_property_range(prop, 0.0f, 1.0f);
2732         RNA_def_property_ui_text(prop, "H", "Hue tolerance for colors to be considered a keying color");
2733         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2734         
2735         prop = RNA_def_property(srna, "color_saturation", PROP_FLOAT, PROP_NONE);
2736         RNA_def_property_float_sdna(prop, NULL, "t2");
2737         RNA_def_property_range(prop, 0.0f, 1.0f);
2738         RNA_def_property_ui_text(prop, "S", "Saturation Tolerance for the color");
2739         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2740         
2741         prop = RNA_def_property(srna, "color_value", PROP_FLOAT, PROP_NONE);
2742         RNA_def_property_float_sdna(prop, NULL, "t3");
2743         RNA_def_property_range(prop, 0.0f, 1.0f);
2744         RNA_def_property_ui_text(prop, "V", "Value Tolerance for the color");
2745         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2746 }
2747
2748 static void def_cmp_distance_matte(StructRNA *srna)
2749 {
2750         PropertyRNA *prop;
2751         
2752         static EnumPropertyItem color_space_items[] = {
2753                 {1, "RGB", 0, "RGB", "RGB color space"},
2754                 {2, "YCC", 0, "YCC", "YCbCr Suppression"},
2755                 {0, NULL, 0, NULL, NULL}
2756         };
2757
2758         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
2759
2760         prop = RNA_def_property(srna, "channel", PROP_ENUM, PROP_NONE);
2761         RNA_def_property_enum_sdna(prop, NULL, "channel");
2762         RNA_def_property_enum_items(prop, color_space_items);
2763         RNA_def_property_ui_text(prop, "Channel", "");
2764         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2765
2766         
2767         prop = RNA_def_property(srna, "tolerance", PROP_FLOAT, PROP_NONE);
2768         RNA_def_property_float_sdna(prop, NULL, "t1");
2769         RNA_def_property_float_funcs(prop, NULL, "rna_distance_matte_t1_set", NULL);
2770         RNA_def_property_range(prop, 0.0f, 1.0f);
2771         RNA_def_property_ui_text(prop, "Tolerance", "Color distances below this threshold are keyed");
2772         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2773         
2774         prop = RNA_def_property(srna, "falloff", PROP_FLOAT, PROP_NONE);
2775         RNA_def_property_float_sdna(prop, NULL, "t2");
2776         RNA_def_property_float_funcs(prop, NULL, "rna_distance_matte_t2_set", NULL);
2777         RNA_def_property_range(prop, 0.0f, 1.0f);
2778         RNA_def_property_ui_text(prop, "Falloff", "Color distances below this additional threshold are partially keyed");
2779         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2780 }
2781
2782 static void def_cmp_color_spill(StructRNA *srna)
2783 {
2784         PropertyRNA *prop;
2785
2786         static EnumPropertyItem channel_items[] = {
2787                 {1, "R", 0, "R", "Red Spill Suppression"},
2788                 {2, "G", 0, "G", "Green Spill Suppression"},
2789                 {3, "B", 0, "B", "Blue Spill Suppression"},
2790                 {0, NULL, 0, NULL, NULL}
2791         };
2792
2793         static EnumPropertyItem limit_channel_items[] = {
2794                 {1, "R", 0, "R", "Limit by Red"},
2795                 {2, "G", 0, "G", "Limit by Green"},
2796                 {3, "B", 0, "B", "Limit by Blue"},
2797                 {0, NULL, 0, NULL, NULL}
2798         };
2799
2800         static EnumPropertyItem algorithm_items[] = {
2801                 {0, "SIMPLE", 0, "Simple", "Simple Limit Algorithm"},
2802                 {1, "AVERAGE", 0, "Average", "Average Limit Algorithm"},
2803                 {0, NULL, 0, NULL, NULL}
2804         };
2805         
2806         prop = RNA_def_property(srna, "channel", PROP_ENUM, PROP_NONE);
2807         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2808         RNA_def_property_enum_items(prop, channel_items);
2809         RNA_def_property_ui_text(prop, "Channel", "");
2810         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2811         
2812         prop = RNA_def_property(srna, "limit_method", PROP_ENUM, PROP_NONE);
2813         RNA_def_property_enum_sdna(prop, NULL, "custom2");
2814         RNA_def_property_enum_items(prop, algorithm_items);
2815         RNA_def_property_ui_text(prop, "Algorithm", "");
2816         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2817
2818         RNA_def_struct_sdna_from(srna, "NodeColorspill", "storage");
2819
2820         prop = RNA_def_property(srna, "limit_channel", PROP_ENUM, PROP_NONE);
2821         RNA_def_property_enum_sdna(prop, NULL, "limchan");
2822         RNA_def_property_enum_items(prop, limit_channel_items);
2823         RNA_def_property_ui_text(prop, "Limit Channel", "");
2824         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2825
2826         prop = RNA_def_property(srna, "ratio", PROP_FLOAT, PROP_NONE);
2827         RNA_def_property_float_sdna(prop, NULL, "limscale");
2828         RNA_def_property_range(prop, 0.5f, 1.5f);
2829         RNA_def_property_ui_text(prop, "Ratio", "Scale limit by value");
2830         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2831
2832         prop = RNA_def_property(srna, "use_unspill", PROP_BOOLEAN, PROP_NONE);
2833         RNA_def_property_boolean_sdna(prop, NULL, "unspill", 0);
2834         RNA_def_property_ui_text(prop, "Unspill", "Compensate all channels (differently) by hand");
2835         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2836
2837         prop = RNA_def_property(srna, "unspill_red", PROP_FLOAT, PROP_NONE);
2838         RNA_def_property_float_sdna(prop, NULL, "uspillr");
2839         RNA_def_property_range(prop, 0.0f, 1.5f);
2840         RNA_def_property_ui_text(prop, "R", "Red spillmap scale");
2841         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2842
2843         prop = RNA_def_property(srna, "unspill_green", PROP_FLOAT, PROP_NONE);
2844         RNA_def_property_float_sdna(prop, NULL, "uspillg");
2845         RNA_def_property_range(prop, 0.0f, 1.5f);
2846         RNA_def_property_ui_text(prop, "G", "Green spillmap scale");
2847         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2848
2849         prop = RNA_def_property(srna, "unspill_blue", PROP_FLOAT, PROP_NONE);
2850         RNA_def_property_float_sdna(prop, NULL, "uspillb");
2851         RNA_def_property_range(prop, 0.0f, 1.5f);
2852         RNA_def_property_ui_text(prop, "B", "Blue spillmap scale");
2853         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2854 }
2855
2856 static void def_cmp_luma_matte(StructRNA *srna)
2857 {
2858         PropertyRNA *prop;
2859         
2860         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
2861         
2862         prop = RNA_def_property(srna, "limit_max", PROP_FLOAT, PROP_NONE);
2863         RNA_def_property_float_sdna(prop, NULL, "t1");
2864         RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t1_set", NULL);
2865         RNA_def_property_range(prop, 0.0f, 1.0f);
2866         RNA_def_property_ui_text(prop, "High", "Values higher than this setting are 100% opaque");
2867         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2868         
2869         prop = RNA_def_property(srna, "limit_min", PROP_FLOAT, PROP_NONE);
2870         RNA_def_property_float_sdna(prop, NULL, "t2");
2871         RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t2_set", NULL);
2872         RNA_def_property_range(prop, 0.0f, 1.0f);
2873         RNA_def_property_ui_text(prop, "Low", "Values lower than this setting are 100% keyed");
2874         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2875 }
2876
2877 static void def_cmp_chroma_matte(StructRNA *srna)
2878 {
2879         PropertyRNA *prop;
2880         
2881         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
2882         
2883         prop = RNA_def_property(srna, "tolerance", PROP_FLOAT, PROP_ANGLE);
2884         RNA_def_property_float_sdna(prop, NULL, "t1");
2885         RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t1_set", NULL);
2886         RNA_def_property_range(prop, DEG2RADF(1.0f), DEG2RADF(80.0f));
2887         RNA_def_property_ui_text(prop, "Acceptance", "Tolerance for a color to be considered a keying color");
2888         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2889         
2890         prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_ANGLE);
2891         RNA_def_property_float_sdna(prop, NULL, "t2");
2892         RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t2_set", NULL);
2893         RNA_def_property_range(prop, 0.0f, DEG2RADF(30.0f));
2894         RNA_def_property_ui_text(prop, "Cutoff", "Tolerance below which colors will be considered as exact matches");
2895         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2896
2897         prop = RNA_def_property(srna, "lift", PROP_FLOAT, PROP_NONE);
2898         RNA_def_property_float_sdna(prop, NULL, "fsize");
2899         RNA_def_property_range(prop, 0.0f, 1.0f);
2900         RNA_def_property_ui_text(prop, "Lift", "Alpha lift");
2901         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2902         
2903         prop = RNA_def_property(srna, "gain", PROP_FLOAT, PROP_NONE);
2904         RNA_def_property_float_sdna(prop, NULL, "fstrength");
2905         RNA_def_property_range(prop, 0.0f, 1.0f);
2906         RNA_def_property_ui_text(prop, "Falloff", "Alpha falloff");
2907         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2908         
2909         prop = RNA_def_property(srna, "shadow_adjust", PROP_FLOAT, PROP_NONE);
2910         RNA_def_property_float_sdna(prop, NULL, "t3");
2911         RNA_def_property_range(prop, 0.0f, 1.0f);
2912         RNA_def_property_ui_text(prop, "Shadow Adjust", "Adjusts the brightness of any shadows captured");
2913         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2914 }
2915
2916 static void def_cmp_channel_matte(StructRNA *srna)
2917 {
2918         PropertyRNA *prop;
2919         
2920         static EnumPropertyItem color_space_items[] = {
2921                 {CMP_NODE_CHANNEL_MATTE_CS_RGB, "RGB", 0, "RGB",   "RGB Color Space"},
2922                 {CMP_NODE_CHANNEL_MATTE_CS_HSV, "HSV", 0, "HSV",   "HSV Color Space"},
2923                 {CMP_NODE_CHANNEL_MATTE_CS_YUV, "YUV", 0, "YUV",   "YUV Color Space"},
2924                 {CMP_NODE_CHANNEL_MATTE_CS_YCC, "YCC", 0, "YCbCr", "YCbCr Color Space"},
2925                 {0, NULL, 0, NULL, NULL}
2926         };
2927
2928         static EnumPropertyItem algorithm_items[] = {
2929                 {0, "SINGLE", 0, "Single", "Limit by single channel"},
2930                 {1, "MAX", 0, "Max", "Limit by max of other channels "},
2931                 {0, NULL, 0, NULL, NULL}
2932         };
2933         
2934         prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
2935         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2936         RNA_def_property_enum_items(prop, color_space_items);
2937         RNA_def_property_ui_text(prop, "Color Space", "");
2938         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2939         
2940         prop = RNA_def_property(srna, "matte_channel", PROP_ENUM, PROP_NONE);
2941         RNA_def_property_enum_sdna(prop, NULL, "custom2");
2942         RNA_def_property_enum_items(prop, prop_tri_channel_items);
2943         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Node_channel_itemf");
2944         RNA_def_property_ui_text(prop, "Channel", "Channel used to determine matte");
2945         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2946
2947         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
2948
2949         prop = RNA_def_property(srna, "limit_method", PROP_ENUM, PROP_NONE);
2950         RNA_def_property_enum_sdna(prop, NULL, "algorithm");
2951         RNA_def_property_enum_items(prop, algorithm_items);
2952         RNA_def_property_ui_text(prop, "Algorithm", "Algorithm to use to limit channel");
2953         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2954
2955         prop = RNA_def_property(srna, "limit_channel", PROP_ENUM, PROP_NONE);
2956         RNA_def_property_enum_sdna(prop, NULL, "channel");
2957         RNA_def_property_enum_items(prop, prop_tri_channel_items);
2958         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Node_channel_itemf");
2959         RNA_def_property_ui_text(prop, "Limit Channel", "Limit by this channel's value");
2960         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2961         
2962         prop = RNA_def_property(srna, "limit_max", PROP_FLOAT, PROP_NONE);
2963         RNA_def_property_float_sdna(prop, NULL, "t1");
2964         RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t1_set", NULL);
2965         RNA_def_property_range(prop, 0.0f, 1.0f);
2966         RNA_def_property_ui_text(prop, "High", "Values higher than this setting are 100% opaque");
2967         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2968         
2969         prop = RNA_def_property(srna, "limit_min", PROP_FLOAT, PROP_NONE);
2970         RNA_def_property_float_sdna(prop, NULL, "t2");
2971         RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t2_set", NULL);
2972         RNA_def_property_range(prop, 0.0f, 1.0f);
2973         RNA_def_property_ui_text(prop, "Low", "Values lower than this setting are 100% keyed");
2974         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2975 }
2976
2977 static void def_cmp_flip(StructRNA *srna)
2978 {
2979         PropertyRNA *prop;
2980         
2981         prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
2982         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2983         RNA_def_property_enum_items(prop, node_flip_items);
2984         RNA_def_property_ui_text(prop, "Axis", "");
2985         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2986 }
2987
2988 static void def_cmp_splitviewer(StructRNA *srna)
2989 {
2990         PropertyRNA *prop;
2991         
2992         static EnumPropertyItem axis_items[] = {
2993                 {0, "X",  0, "X",     ""},
2994                 {1, "Y",  0, "Y",     ""},
2995                 {0, NULL, 0, NULL, NULL}
2996         };
2997         
2998         prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
2999         RNA_def_property_enum_sdna(prop, NULL, "custom2");
3000         RNA_def_property_enum_items(prop, axis_items);
3001         RNA_def_property_ui_text(prop, "Axis", "");
3002         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3003
3004         prop = RNA_def_property(srna, "factor", PROP_INT, PROP_FACTOR);
3005         RNA_def_property_int_sdna(prop, NULL, "custom1");
3006         RNA_def_property_range(prop, 0, 100);
3007         RNA_def_property_ui_text(prop, "Factor", "");
3008         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3009 }
3010
3011 static void def_cmp_id_mask(StructRNA *srna)
3012 {
3013         PropertyRNA *prop;
3014         
3015         prop = RNA_def_property(srna, "index", PROP_INT, PROP_NONE);
3016         RNA_def_property_int_sdna(prop, NULL, "custom1");
3017         RNA_def_property_range(prop, 0, 32767);
3018         RNA_def_property_ui_text(prop, "Index", "Pass index number to convert to alpha");
3019         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3020
3021         prop = RNA_def_property(srna, "use_antialiasing", PROP_BOOLEAN, PROP_NONE);
3022         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 0);
3023         RNA_def_property_ui_text(prop, "Anti-Aliasing", "Apply an anti-aliasing filter to the mask");
3024         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3025 }
3026
3027 static void def_cmp_double_edge_mask(StructRNA *srna)
3028 {
3029         PropertyRNA *prop;
3030
3031         static EnumPropertyItem BufEdgeMode_items[] = {
3032                 {0, "BLEED_OUT",  0, "Bleed Out",     "Allow mask pixels to bleed along edges"},
3033                 {1, "KEEP_IN",  0, "Keep In",     "Restrict mask pixels from touching edges"},
3034                 {0, NULL, 0, NULL, NULL}
3035         };
3036
3037         static EnumPropertyItem InnerEdgeMode_items[] = {
3038                 {0, "ALL", 0, "All", "All pixels on inner mask edge are considered during mask calculation"},
3039                 {1, "ADJACENT_ONLY", 0, "Adjacent Only",
3040                  "Only inner mask pixels adjacent to outer mask pixels are considered during mask calculation"},
3041                 {0, NULL, 0, NULL, NULL}
3042         };
3043
3044         prop = RNA_def_property(srna, "inner_mode", PROP_ENUM, PROP_NONE);
3045         RNA_def_property_enum_sdna(prop, NULL, "custom2");
3046         RNA_def_property_enum_items(prop, InnerEdgeMode_items);
3047         RNA_def_property_ui_text(prop, "Inner Edge Mode", "");
3048         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3049
3050         prop = RNA_def_property(srna, "edge_mode", PROP_ENUM, PROP_NONE);
3051         RNA_def_property_enum_sdna(prop, NULL, "custom1");
3052         RNA_def_property_enum_items(prop, BufEdgeMode_items);
3053         RNA_def_property_ui_text(prop, "Buffer Edge Mode", "");
3054         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3055 }
3056
3057 static void def_cmp_map_uv(StructRNA *srna)
3058 {
3059         PropertyRNA *prop;
3060
3061         prop = RNA_def_property(srna, "alpha", PROP_INT, PROP_FACTOR);
3062         RNA_def_property_int_sdna(prop, NULL, "custom1");
3063         RNA_def_property_range(prop, 0, 100);
3064         RNA_def_property_ui_text(prop, "Alpha", "");
3065         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3066 }
3067
3068 static void def_cmp_defocus(StructRNA *srna)
3069 {
3070         PropertyRNA *prop;
3071         
3072         static EnumPropertyItem bokeh_items[] = {
3073                 {8, "OCTAGON",  0, "Octagonal",  "8 sides"},
3074                 {7, "HEPTAGON", 0, "Heptagonal", "7 sides"},
3075                 {6, "HEXAGON",  0, "Hexagonal",  "6 sides"},
3076                 {5, "PENTAGON", 0, "Pentagonal", "5 sides"},
3077                 {4, "SQUARE",   0, "Square",     "4 sides"},
3078                 {3, "TRIANGLE", 0, "Triangular", "3 sides"},
3079                 {0, "CIRCLE",   0, "Circular",   ""},
3080                 {0, NULL, 0, NULL, NULL}
3081         };
3082         
3083         RNA_def_struct_sdna_from(srna, "NodeDefocus", "storage");
3084         
3085         prop = RNA_def_property(srna, "bokeh", PROP_ENUM, PROP_NONE);
3086         RNA_def_property_enum_sdna(prop, NULL, "bktype");
3087         RNA_def_property_enum_items(prop, bokeh_items);
3088         RNA_def_property_ui_text(prop, "Bokeh Type", "");
3089         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3090
3091         /* TODO: angle in degrees */
3092         prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
3093         RNA_def_property_float_sdna(prop, NULL, "rotation");
3094         RNA_def_property_range(prop, 0.0f, DEG2RADF(90.0f));
3095         RNA_def_property_ui_text(prop, "Angle", "Bokeh shape rotation offset");
3096         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3097         
3098         prop = RNA_def_property(srna, "use_gamma_correction", PROP_BOOLEAN, PROP_NONE);
3099         RNA_def_property_boolean_sdna(prop, NULL, "gamco", 1);
3100         RNA_def_property_ui_text(prop, "Gamma Correction", "Enable gamma correction before and after main process");
3101         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3102
3103         /* TODO */
3104         prop = RNA_def_property(srna, "f_stop", PROP_FLOAT, PROP_NONE);
3105         RNA_def_property_float_sdna(prop, NULL, "fstop");
3106         RNA_def_property_range(prop, 0.0f, 128.0f);
3107         RNA_def_property_ui_text(prop, "fStop",
3108                                  "Amount of focal blur, 128=infinity=perfect focus, half the value doubles "
3109                                  "the blur radius");
3110         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3111         
3112         prop = RNA_def_property(srna, "blur_max", PROP_FLOAT, PROP_NONE);
3113         RNA_def_property_float_sdna(prop, NULL, "maxblur");
3114         RNA_def_property_range(prop, 0.0f, 10000.0f);
3115         RNA_def_property_ui_text(prop, "Max Blur", "Blur limit, maximum CoC radius");
3116         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3117         
3118         prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_NONE);
3119         RNA_def_property_float_sdna(prop, NULL, "bthresh");
3120         RNA_def_property_range(prop, 0.0f, 100.0f);
3121         RNA_def_property_ui_text(prop, "Threshold",
3122                                  "CoC radius threshold, prevents background bleed on in-focus midground, 0=off");
3123         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3124         
3125         prop = RNA_def_property(srna, "use_preview", PROP_BOOLEAN, PROP_NONE);
3126         RNA_def_property_boolean_sdna(prop, NULL, "preview", 1);
3127         RNA_def_property_ui_text(prop, "Preview", "Enable low quality mode, useful for preview");
3128         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3129
3130         prop = RNA_def_property(srna, "use_zbuffer", PROP_BOOLEAN, PROP_NONE);
3131         RNA_def_property_boolean_negative_sdna(prop, NULL, "no_zbuf", 1);
3132         RNA_def_property_ui_text(prop, "Use Z-Buffer",
3133                                  "Disable when using an image as input instead of actual z-buffer "
3134                                  "(auto enabled if node not image based, eg. time node)");
3135         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3136         
3137         prop = RNA_def_property(srna, "z_scale", PROP_FLOAT, PROP_NONE);
3138         RNA_def_property_float_sdna(prop, NULL, "scale");
3139         RNA_def_property_range(prop, 0.0f, 1000.0f);
3140         RNA_def_property_ui_text(prop, "Z-Scale",
3141                                  "Scale the Z input when not using a z-buffer, controls maximum blur designated "
3142                                  "by the color white or input value 1");
3143         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3144 }
3145
3146 static void def_cmp_invert(StructRNA *srna)
3147 {
3148         PropertyRNA *prop;
3149         
3150         prop = RNA_def_property(srna, "invert_rgb", PROP_BOOLEAN, PROP_NONE);
3151         RNA_def_property_boolean_sdna(prop, NULL, "custom1", CMP_CHAN_RGB);
3152         RNA_def_property_ui_text(prop, "RGB", "");
3153         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3154         
3155         prop = RNA_def_property(srna, "invert_alpha", PROP_BOOLEAN, PROP_NONE);
3156         RNA_def_property_boolean_sdna(prop, NULL, "custom1", CMP_CHAN_A);
3157         RNA_def_property_ui_text(prop, "Alpha", "");
3158         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3159 }
3160
3161 static void def_cmp_crop(StructRNA *srna)
3162 {
3163         PropertyRNA *prop;
3164         
3165         prop = RNA_def_property(srna, "use_crop_size", PROP_BOOLEAN, PROP_NONE);
3166         RNA_def_property_boolean_sdna(prop, NULL, "custom1", 1);
3167         RNA_def_property_ui_text(prop, "Crop Image Size", "Whether to crop the size of the input image");
3168         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3169
3170         prop = RNA_def_property(srna, "relative", PROP_BOOLEAN, PROP_NONE);
3171         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 1);
3172         RNA_def_property_ui_text(prop, "Relative", "Use relative values to crop image");
3173         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3174
3175         RNA_def_struct_sdna_from(srna, "NodeTwoXYs", "storage");
3176
3177         prop = RNA_def_property(srna, "min_x", PROP_INT, PROP_NONE);
3178         RNA_def_property_int_sdna(prop, NULL, "x1");
3179         RNA_def_property_range(prop, 0, 10000);
3180         RNA_def_property_ui_text(prop, "X1", "");
3181         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3182         
3183         prop = RNA_def_property(srna, "max_x", PROP_INT, PROP_NONE);
3184         RNA_def_property_int_sdna(prop, NULL, "x2");
3185         RNA_def_property_range(prop, 0, 10000);
3186         RNA_def_property_ui_text(prop, "X2", "");
3187         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3188         
3189         prop = RNA_def_property(srna, "min_y", PROP_INT, PROP_NONE);
3190         RNA_def_property_int_sdna(prop, NULL, "y1");
3191         RNA_def_property_range(prop, 0, 10000);
3192         RNA_def_property_ui_text(prop, "Y1", "");
3193         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3194         
3195         prop = RNA_def_property(srna, "max_y", PROP_INT, PROP_NONE);
3196         RNA_def_property_int_sdna(prop, NULL, "y2");
3197         RNA_def_property_range(prop, 0, 10000);
3198         RNA_def_property_ui_text(prop, "Y2", "");
3199         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3200
3201         prop = RNA_def_property(srna, "rel_min_x", PROP_FLOAT, PROP_NONE);
3202         RNA_def_property_float_sdna(prop, NULL, "fac_x1");
3203         RNA_def_property_range(prop, 0.0, 1.0);
3204         RNA_def_property_ui_text(prop, "X1", "");
3205         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3206
3207         prop = RNA_def_property(srna, "rel_max_x", PROP_FLOAT, PROP_NONE);
3208         RNA_def_property_float_sdna(prop, NULL, "fac_x2");
3209         RNA_def_property_range(prop, 0.0, 1.0);
3210         RNA_def_property_ui_text(prop, "X2", "");
3211         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3212
3213         prop = RNA_def_property(srna, "rel_min_y", PROP_FLOAT, PROP_NONE);
3214         RNA_def_property_float_sdna(prop, NULL, "fac_y1");
3215         RNA_def_property_range(prop, 0.0, 1.0);
3216         RNA_def_property_ui_text(prop, "Y1", "");
3217         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3218
3219         prop = RNA_def_property(srna, "rel_max_y", PROP_FLOAT, PROP_NONE);
3220         RNA_def_property_float_sdna(prop, NULL, "fac_y2");
3221         RNA_def_property_range(prop, 0.0, 1.0);
3222         RNA_def_property_ui_text(prop, "Y2", "");
3223         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3224 }
3225
3226 static void def_cmp_dblur(StructRNA *srna)
3227 {
3228         PropertyRNA *prop;
3229         
3230         RNA_def_struct_sdna_from(srna, "NodeDBlurData", "storage");
3231         
3232         prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
3233         RNA_def_property_int_sdna(prop, NULL, "iter");
3234         RNA_def_property_range(prop, 1, 32);
3235         RNA_def_property_ui_text(prop, "Iterations", "");
3236         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3237         
3238         prop = RNA_def_property(srna, "use_wrap", PROP_BOOLEAN, PROP_NONE);
3239         RNA_def_property_boolean_sdna(prop, NULL, "wrap", 1);
3240         RNA_def_property_ui_text(prop, "Wrap", "");
3241         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3242         
3243         prop = RNA_def_property(srna, "center_x", PROP_FLOAT, PROP_NONE);
3244         RNA_def_property_float_sdna(prop, NULL, "center_x");
3245         RNA_def_property_range(prop, 0.0f, 1.0f);
3246         RNA_def_property_ui_text(prop, "Center X", "");
3247         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3248         
3249         prop = RNA_def_property(srna, "center_y", PROP_FLOAT, PROP_NONE);
3250         RNA_def_property_float_sdna(prop, NULL, "center_y");
3251         RNA_def_property_range(prop, 0.0f, 1.0f);
3252         RNA_def_property_ui_text(prop, "Center Y", "");
3253         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3254         
3255         prop = RNA_def_property(srna, "distance", PROP_FLOAT, PROP_NONE);
3256         RNA_def_property_float_sdna(prop, NULL, "distance");
3257         RNA_def_property_range(prop, -1.0f, 1.0f);
3258         RNA_def_property_ui_text(prop, "Distance", "");
3259         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3260         
3261         prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
3262         RNA_def_property_float_sdna(prop, NULL, "angle");
3263         RNA_def_property_range(prop, 0.0f, DEG2RADF(360.0f));
3264         RNA_def_property_ui_text(prop, "Angle", "");
3265         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3266         
3267         prop = RNA_def_property(srna, "spin", PROP_FLOAT, PROP_ANGLE);
3268         RNA_def_property_float_sdna(prop, NULL, "spin");
3269         RNA_def_property_range(prop, DEG2RADF(-360.0f), DEG2RADF(360.0f));
3270         RNA_def_property_ui_text(prop, "Spin",