Started wrapping nodes in RNA. Only shader nodes have all their options wrapped;
[blender.git] / source / blender / makesrna / intern / rna_nodetree.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * Contributor(s): Blender Foundation (2008), Nathan Letwory, Robin Allen
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include "RNA_define.h"
29 #include "RNA_types.h"
30
31 #include "rna_internal.h"
32
33 #include "DNA_node_types.h"
34 #include "BKE_node.h"
35
36 #ifdef RNA_RUNTIME
37
38 StructRNA *rna_Node_refine(struct PointerRNA *ptr)
39 {
40         bNode *node= (bNode*)ptr->data;
41
42         switch(node->type) {
43                 
44                 #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
45                         case ID: return &RNA_##Category##StructName;
46                                 
47                 #include "rna_nodetree_types.h"
48                 
49                 #undef DefNode
50                 
51                 default:
52                         return &RNA_Node;
53         }
54 }
55
56 #else
57
58 #define MaxNodes 1000
59
60 enum
61 {
62         Category_NoCategory,
63         Category_ShaderNode,
64         Category_CompositorNode,
65         Category_TextureNode
66 };
67
68 typedef struct NodeInfo
69 {
70         int defined;
71         int category;
72         const char *enum_name;
73         const char *struct_name;
74         const char *base_name;
75         const char *ui_name;
76         const char *ui_desc;
77 } NodeInfo;
78
79 static NodeInfo nodes[MaxNodes];
80
81 static void reg_node(
82         int ID, 
83         int category,
84         const char *enum_name,
85         const char *struct_name,
86         const char *base_name,
87         const char *ui_name,
88         const char *ui_desc
89 ){
90         NodeInfo *ni = nodes + ID;
91         
92         ni->defined = 1;
93         ni->category = category;
94         ni->enum_name = enum_name;
95         ni->struct_name = struct_name;
96         ni->base_name = base_name;
97         ni->ui_name = ui_name;
98         ni->ui_desc = ui_desc;
99 }
100
101 static void init(void)
102 {
103         memset(nodes, 0, sizeof nodes);
104         
105         #define Str(x) #x
106         
107         #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
108                 reg_node(ID, Category_##Category, EnumName, Str(Category##StructName), #Category, UIName, UIDesc);
109                 
110         #include "rna_nodetree_types.h"
111         
112         #undef DefNode
113         #undef Str
114 }
115
116 static StructRNA* def_node(BlenderRNA *brna, int node_id)
117 {
118         StructRNA *srna;
119         NodeInfo *node = nodes + node_id;
120         
121         srna= RNA_def_struct(brna, node->struct_name, node->base_name);
122         RNA_def_struct_ui_text(srna, node->ui_name, node->ui_desc);
123         RNA_def_struct_sdna(srna, "bNode");
124         
125         return srna;
126 }
127
128 static EnumPropertyItem* alloc_node_type_items(int category)
129 {
130         int i;
131         int count = 2;
132         EnumPropertyItem *item, *items;
133         
134         for(i=0; i<MaxNodes; i++)
135                 if(nodes[i].defined && nodes[i].category == category)
136                         count++;
137                 
138         item = items = malloc(count * sizeof(EnumPropertyItem));
139         
140         for(i=0; i<MaxNodes; i++) {
141                 NodeInfo *node = nodes + i;
142                 if(node->defined && node->category == category) {
143                         item->value = i;
144                         item->identifier = node->enum_name;
145                         item->name = node->ui_name;
146                         item->description = node->ui_desc;
147                 
148                         item++;
149                 }
150         }
151         
152         item->value = NODE_DYNAMIC;
153         item->identifier = "SCRIPT";
154         item->name = "Script";
155         item->description = "";
156         
157         item++;
158         
159         memset(item, 0, sizeof(EnumPropertyItem));
160         
161         return items;
162 }
163
164
165 /* -- Common nodes ---------------------------------------------------------- */
166
167 static void def_math(BlenderRNA *brna, int id)
168 {
169         StructRNA *srna;
170         PropertyRNA *prop;
171         
172         static EnumPropertyItem items[] ={
173                 { 0, "ADD",          "Add",          ""},
174                 { 1, "SUBTRACT",     "Subtract",     ""},
175                 { 2, "MULTIPLY",     "Multiply",     ""},
176                 { 3, "DIVIDE",       "Divide",       ""},
177                 { 4, "SINE",         "Sine",         ""},
178                 { 5, "COSINE",       "Cosine",       ""},
179                 { 6, "TANGENT",      "Tangent",      ""},
180                 { 7, "ARCSINE",      "Arcsine",      ""},
181                 { 8, "ARCCOSINE",    "Arccosine",    ""},
182                 { 9, "ARCTANGENT",   "Arctangent",   ""},
183                 {10, "POWER",        "Power",        ""},
184                 {11, "LOGARITHM",    "Logarithm",    ""},
185                 {12, "MINIMUM",      "Minimum",      ""},
186                 {13, "MAXIMUM",      "Maximum",      ""},
187                 {14, "ROUND",        "Round",        ""},
188                 {15, "LESS_THAN",    "Less Than",    ""},
189                 {16, "GREATER_THAN", "Greater Than", ""},
190                 
191                 {0, NULL, NULL, NULL}
192         };
193         
194         srna= def_node(brna, id);
195         
196         prop= RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
197         RNA_def_property_enum_sdna(prop, NULL, "custom1");
198         RNA_def_property_enum_items(prop, items);
199         RNA_def_property_ui_text(prop, "Operation", "");
200 }
201
202 static void def_vector_math(BlenderRNA *brna, int id)
203 {
204         StructRNA *srna;
205         PropertyRNA *prop;
206         
207         static EnumPropertyItem items[] ={
208                 {0, "ADD",           "Add",           ""},
209                 {1, "SUBTRACT",      "Subtract",      ""},
210                 {2, "AVERAGE",       "Average",       ""},
211                 {3, "DOT_PRODUCT",   "Dot Product",   ""},
212                 {4, "CROSS_PRODUCT", "Cross Product", ""},
213                 {5, "NORMALIZE",     "Normalize",     ""},
214                 
215                 {0, NULL, NULL, NULL}
216         };
217         
218         srna= def_node(brna, id);
219         
220         prop= RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
221         RNA_def_property_enum_sdna(prop, NULL, "custom1");
222         RNA_def_property_enum_items(prop, items);
223         RNA_def_property_ui_text(prop, "Operation", "");
224 }
225
226 static void def_rgb_curve(BlenderRNA *brna, int id)
227 {
228         StructRNA *srna;
229         PropertyRNA *prop;
230         
231         srna= def_node(brna, id);
232         
233         prop= RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
234         RNA_def_property_pointer_sdna(prop, NULL, "storage");
235         RNA_def_property_struct_type(prop, "CurveMapping");
236         RNA_def_property_ui_text(prop, "Mapping", "");
237 }
238
239 static void def_vector_curve(BlenderRNA *brna, int id)
240 {
241         StructRNA *srna;
242         PropertyRNA *prop;
243         
244         srna= def_node(brna, id);
245         
246         prop= RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
247         RNA_def_property_pointer_sdna(prop, NULL, "storage");
248         RNA_def_property_struct_type(prop, "CurveMapping");
249         RNA_def_property_ui_text(prop, "Mapping", "");
250 }
251
252 static void def_val_to_rgb(BlenderRNA *brna, int id)
253 {
254         StructRNA *srna;
255         PropertyRNA *prop;
256         
257         srna= def_node(brna, id);
258         
259         /* TODO: uncomment when ColorBand is wrapped */
260         /*prop= RNA_def_property(srna, "color_band", PROP_POINTER, PROP_NONE);
261         RNA_def_property_pointer_sdna(prop, NULL, "storage");
262         RNA_def_property_struct_type(prop, "ColorBand");
263         RNA_def_property_ui_text(prop, "Color Band", "");*/
264 }
265
266 static void def_mix_rgb(BlenderRNA *brna, int id)
267 {
268         StructRNA *srna;
269         PropertyRNA *prop;
270         
271         static EnumPropertyItem blend_type_items[] ={
272                 { 0, "MIX",        "Mix",         ""},
273                 { 1, "ADD",        "Add",         ""},
274                 { 3, "SUBTRACT",   "Subtract",    ""},
275                 { 2, "MULTIPLY",   "Multiply",    ""},
276                 { 4, "SCREEN",     "Screen",      ""},
277                 { 9, "OVERLAY",    "Overlay",     ""},
278                 { 5, "DIVIDE",     "Divide",      ""},
279                 { 6, "DIFFERENCE", "Difference",  ""},
280                 { 7, "DARKEN",     "Darken",      ""},
281                 { 8, "LIGHTEN",    "Lighten",     ""},
282                 {10, "DODGE",      "Dodge",       ""},
283                 {11, "BURN",       "Burn",        ""},
284                 {15, "COLOR",      "Color",       ""},
285                 {14, "VALUE",      "Value",       ""},
286                 {13, "SATURATION", "Saturation",  ""},
287                 {12, "HUE",        "Hue",         ""},
288                 {0, NULL, NULL, NULL}
289         };
290         
291         srna= def_node(brna, id);
292         
293         prop= RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
294         RNA_def_property_enum_sdna(prop, NULL, "custom1");
295         RNA_def_property_enum_items(prop, blend_type_items);
296         RNA_def_property_ui_text(prop, "Blend Type", "");
297         
298         prop= RNA_def_property(srna, "alpha", PROP_BOOLEAN, PROP_NONE);
299         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 1);
300         RNA_def_property_ui_text(prop, "Diffuse", "Include alpha of second input in this operation");
301 }
302
303
304 /* -- Shader Node Storage Types --------------------------------------------- */
305
306 static void rna_def_storage_node_geometry(BlenderRNA *brna)
307 {
308         StructRNA *srna;
309         PropertyRNA *prop;
310         
311         srna= RNA_def_struct(brna, "NodeGeometry", NULL);
312         RNA_def_struct_ui_text(srna, "Node Geometry", "");
313         
314         prop= RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE);
315         RNA_def_property_string_sdna(prop, NULL, "uvname");
316         RNA_def_property_ui_text(prop, "UV Layer", "");
317         
318         prop= RNA_def_property(srna, "color_layer", PROP_STRING, PROP_NONE);
319         RNA_def_property_string_sdna(prop, NULL, "colname");
320         RNA_def_property_ui_text(prop, "Vertex Color Layer", "");
321 }
322
323
324 /* -- Shader Nodes ---------------------------------------------------------- */
325
326 static void def_sh_texture(BlenderRNA *brna, int id)
327 {
328         StructRNA *srna;
329         PropertyRNA *prop;
330         
331         srna= def_node(brna, id);
332         
333         prop= RNA_def_property(srna, "texture", PROP_POINTER, PROP_NONE);
334         RNA_def_property_pointer_sdna(prop, NULL, "id");
335         RNA_def_property_struct_type(prop, "Texture");
336         RNA_def_property_ui_text(prop, "Texture", "");
337         
338         prop= RNA_def_property(srna, "node_output", PROP_INT, PROP_NONE);
339         RNA_def_property_int_sdna(prop, NULL, "custom1");
340         RNA_def_property_ui_text(prop, "Node Output", "For node-based textures, which output node to use");
341 }
342
343 static void def_sh_material(BlenderRNA *brna, int id)
344 {
345         StructRNA *srna;
346         PropertyRNA *prop;
347
348         srna= def_node(brna, id);
349
350         prop= RNA_def_property(srna, "material", PROP_POINTER, PROP_NONE);
351         RNA_def_property_pointer_sdna(prop, NULL, "id");
352         RNA_def_property_struct_type(prop, "Material");
353         RNA_def_property_ui_text(prop, "Material", "");
354
355         prop= RNA_def_property(srna, "diffuse", PROP_BOOLEAN, PROP_NONE);
356         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_DIFF);
357         RNA_def_property_ui_text(prop, "Diffuse", "Material Node outputs Diffuse");
358
359         prop= RNA_def_property(srna, "specular", PROP_BOOLEAN, PROP_NONE);
360         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_SPEC);
361         RNA_def_property_ui_text(prop, "Specular", "Material Node outputs Specular");
362         
363         prop= RNA_def_property(srna, "invert_normal", PROP_BOOLEAN, PROP_NONE);
364         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_NEG);
365         RNA_def_property_ui_text(prop, "Invert Normal", "Material Node uses inverted normal");
366 }
367
368 static void def_sh_mapping(BlenderRNA *brna, int id)
369 {
370         StructRNA *srna;
371         PropertyRNA *prop;
372         
373         srna= def_node(brna, id);
374         
375         prop= RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
376         RNA_def_property_pointer_sdna(prop, NULL, "storage");
377         RNA_def_property_struct_type(prop, "TexMapping");
378         RNA_def_property_ui_text(prop, "Mapping", "");
379 }
380
381 static void def_sh_geometry(BlenderRNA *brna, int id)
382 {
383         StructRNA *srna;
384         PropertyRNA *prop;
385         
386         srna= def_node(brna, id);
387         
388         prop= RNA_def_property(srna, "settings", PROP_POINTER, PROP_NONE);
389         RNA_def_property_pointer_sdna(prop, NULL, "storage");
390         RNA_def_property_struct_type(prop, "NodeGeometry");
391         RNA_def_property_ui_text(prop, "Settings", "");
392 }
393
394 /* -- Compositor Nodes ------------------------------------------------------ */
395
396 /* -- Texture Nodes --------------------------------------------------------- */
397
398 /* -------------------------------------------------------------------------- */
399
400 static void rna_def_shader_node(BlenderRNA *brna)
401 {
402         StructRNA *srna;
403         PropertyRNA *prop;
404         EnumPropertyItem *node_type_items;
405         
406         node_type_items = alloc_node_type_items(Category_ShaderNode);
407
408         srna= RNA_def_struct(brna, "ShaderNode", "Node");
409         RNA_def_struct_ui_text(srna, "Shader Node", "Material shader node.");
410         RNA_def_struct_sdna(srna, "bNode");
411
412         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
413         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
414         RNA_def_property_enum_items(prop, node_type_items);
415         RNA_def_property_ui_text(prop, "Type", "");
416
417         /* Shader storage types */
418         rna_def_storage_node_geometry(brna);
419 }
420
421 static void rna_def_compositor_node(BlenderRNA *brna)
422 {
423         StructRNA *srna;
424         PropertyRNA *prop;
425         EnumPropertyItem *node_type_items;
426         
427         node_type_items = alloc_node_type_items(Category_CompositorNode);
428         
429         srna= RNA_def_struct(brna, "CompositorNode", "Node");
430         RNA_def_struct_ui_text(srna, "Compositor Node", "");
431         RNA_def_struct_sdna(srna, "bNode");
432
433         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
434         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
435         RNA_def_property_enum_items(prop, node_type_items);
436         RNA_def_property_ui_text(prop, "Type", "");
437 }
438
439 static void rna_def_texture_node(BlenderRNA *brna)
440 {
441         StructRNA *srna;
442         PropertyRNA *prop;
443         EnumPropertyItem *node_type_items;
444         
445         node_type_items = alloc_node_type_items(Category_TextureNode);
446         
447         srna= RNA_def_struct(brna, "TextureNode", "Node");
448         RNA_def_struct_ui_text(srna, "Texture Node", "");
449         RNA_def_struct_sdna(srna, "bNode");
450
451         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
452         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
453         RNA_def_property_enum_items(prop, node_type_items);
454         RNA_def_property_ui_text(prop, "Type", "");
455 }
456
457 /* -------------------------------------------------------------------------- */
458
459 static void rna_def_node(BlenderRNA *brna)
460 {
461         StructRNA *srna;
462         PropertyRNA *prop;
463         
464         srna= RNA_def_struct(brna, "Node", NULL);
465         RNA_def_struct_ui_text(srna, "Node", "Node in a node tree.");
466         RNA_def_struct_sdna(srna, "bNode");
467         RNA_def_struct_refine_func(srna, "rna_Node_refine");
468         
469         prop= RNA_def_property(srna, "location", PROP_FLOAT, PROP_VECTOR);
470         RNA_def_property_float_sdna(prop, NULL, "locx");
471         RNA_def_property_array(prop, 2);
472         RNA_def_property_range(prop, -10000.0f, 10000.0f);
473         RNA_def_property_ui_text(prop, "Location", "");
474         
475         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
476         RNA_def_property_ui_text(prop, "Name", "Node name.");
477         RNA_def_struct_name_property(srna, prop);
478 }
479
480 static void rna_def_nodetree(BlenderRNA *brna)
481 {
482         StructRNA *srna;
483         PropertyRNA *prop;
484         
485         srna= RNA_def_struct(brna, "NodeTree", "ID");
486         RNA_def_struct_ui_text(srna, "Node Tree", "Node tree consisting of linked nodes used for materials, textures and compositing.");
487         RNA_def_struct_sdna(srna, "bNodeTree");
488
489         prop= RNA_def_property(srna, "nodes", PROP_COLLECTION, PROP_NONE);
490         RNA_def_property_collection_sdna(prop, NULL, "nodes", NULL);
491         RNA_def_property_struct_type(prop, "Node");
492         RNA_def_property_ui_text(prop, "Nodes", "");
493 }
494
495 static void define_simple_node(BlenderRNA *brna, int id)
496 {
497         def_node(brna, id);
498 }
499
500 static void define_specific_node(BlenderRNA *brna, int id, void (*func)(BlenderRNA*, int))
501 {
502         func(brna, id);
503 }
504
505 void RNA_def_nodetree(BlenderRNA *brna)
506 {
507         init();
508         rna_def_nodetree(brna);
509         rna_def_node(brna);
510         rna_def_shader_node(brna);
511         rna_def_compositor_node(brna);
512         rna_def_texture_node(brna);
513         
514         #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
515                 define_specific_node(brna, ID, DefFunc ? DefFunc : define_simple_node);
516                 
517         #include "rna_nodetree_types.h"
518         
519         #undef DefNode
520 }
521
522 #endif
523