Implemented a basic framework for node-based shaders.
[blender-staging.git] / source / blender / makesrna / intern / rna_linestyle.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).
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_linestyle.c
24  *  \ingroup RNA
25  */
26
27 #include <stdio.h>
28 #include <stdlib.h>
29
30 #include "RNA_define.h"
31 #include "RNA_enum_types.h"
32
33 #include "rna_internal.h"
34
35 #include "DNA_linestyle_types.h"
36 #include "DNA_material_types.h"
37 #include "DNA_texture_types.h"
38
39 #include "WM_types.h"
40 #include "WM_api.h"
41
42 EnumPropertyItem linestyle_color_modifier_type_items[] = {
43         {LS_MODIFIER_ALONG_STROKE, "ALONG_STROKE", ICON_MODIFIER, "Along Stroke", ""},
44         {LS_MODIFIER_DISTANCE_FROM_CAMERA, "DISTANCE_FROM_CAMERA", ICON_MODIFIER, "Distance from Camera", ""},
45         {LS_MODIFIER_DISTANCE_FROM_OBJECT, "DISTANCE_FROM_OBJECT", ICON_MODIFIER, "Distance from Object", ""},
46         {LS_MODIFIER_MATERIAL, "MATERIAL", ICON_MODIFIER, "Material", ""},
47         {0, NULL, 0, NULL, NULL}
48 };
49
50 EnumPropertyItem linestyle_alpha_modifier_type_items[] = {
51         {LS_MODIFIER_ALONG_STROKE, "ALONG_STROKE", ICON_MODIFIER, "Along Stroke", ""},
52         {LS_MODIFIER_DISTANCE_FROM_CAMERA, "DISTANCE_FROM_CAMERA", ICON_MODIFIER, "Distance from Camera", ""},
53         {LS_MODIFIER_DISTANCE_FROM_OBJECT, "DISTANCE_FROM_OBJECT", ICON_MODIFIER, "Distance from Object", ""},
54         {LS_MODIFIER_MATERIAL, "MATERIAL", ICON_MODIFIER, "Material", ""},
55         {0, NULL, 0, NULL, NULL}
56 };
57
58 EnumPropertyItem linestyle_thickness_modifier_type_items[] = {
59         {LS_MODIFIER_ALONG_STROKE, "ALONG_STROKE", ICON_MODIFIER, "Along Stroke", ""},
60         {LS_MODIFIER_CALLIGRAPHY, "CALLIGRAPHY", ICON_MODIFIER, "Calligraphy", ""},
61         {LS_MODIFIER_DISTANCE_FROM_CAMERA, "DISTANCE_FROM_CAMERA", ICON_MODIFIER, "Distance from Camera", ""},
62         {LS_MODIFIER_DISTANCE_FROM_OBJECT, "DISTANCE_FROM_OBJECT", ICON_MODIFIER, "Distance from Object", ""},
63         {LS_MODIFIER_MATERIAL, "MATERIAL", ICON_MODIFIER, "Material", ""},
64         {0, NULL, 0, NULL, NULL}
65 };
66
67 EnumPropertyItem linestyle_geometry_modifier_type_items[] = {
68         {LS_MODIFIER_2D_OFFSET, "2D_OFFSET", ICON_MODIFIER, "2D Offset", ""},
69         {LS_MODIFIER_2D_TRANSFORM, "2D_TRANSFORM", ICON_MODIFIER, "2D Transform", ""},
70         {LS_MODIFIER_BACKBONE_STRETCHER, "BACKBONE_STRETCHER", ICON_MODIFIER, "Backbone Stretcher", ""},
71         {LS_MODIFIER_BEZIER_CURVE, "BEZIER_CURVE", ICON_MODIFIER, "Bezier Curve", ""},
72         {LS_MODIFIER_BLUEPRINT, "BLUEPRINT", ICON_MODIFIER, "Blueprint", ""},
73         {LS_MODIFIER_GUIDING_LINES, "GUIDING_LINES", ICON_MODIFIER, "Guiding Lines", ""},
74         {LS_MODIFIER_PERLIN_NOISE_1D, "PERLIN_NOISE_1D", ICON_MODIFIER, "Perlin Noise 1D", ""},
75         {LS_MODIFIER_PERLIN_NOISE_2D, "PERLIN_NOISE_2D", ICON_MODIFIER, "Perlin Noise 2D", ""},
76         {LS_MODIFIER_POLYGONIZATION, "POLYGONIZATION", ICON_MODIFIER, "Polygonization", ""},
77         {LS_MODIFIER_SAMPLING, "SAMPLING", ICON_MODIFIER, "Sampling", ""},
78         {LS_MODIFIER_SINUS_DISPLACEMENT, "SINUS_DISPLACEMENT", ICON_MODIFIER, "Sinus Displacement", ""},
79         {LS_MODIFIER_SPATIAL_NOISE, "SPATIAL_NOISE", ICON_MODIFIER, "Spatial Noise", ""},
80         {LS_MODIFIER_TIP_REMOVER, "TIP_REMOVER", ICON_MODIFIER, "Tip Remover", ""},
81         {0, NULL, 0, NULL, NULL}
82 };
83
84 #ifdef RNA_RUNTIME
85
86 #include "BKE_linestyle.h"
87 #include "BKE_texture.h"
88 #include "BKE_depsgraph.h"
89
90 #include "ED_node.h"
91
92 #include "RNA_access.h"
93
94 static StructRNA *rna_LineStyle_color_modifier_refine(struct PointerRNA *ptr)
95 {
96         LineStyleModifier *m = (LineStyleModifier *)ptr->data;
97
98         switch (m->type) {
99                 case LS_MODIFIER_ALONG_STROKE:
100                         return &RNA_LineStyleColorModifier_AlongStroke;
101                 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
102                         return &RNA_LineStyleColorModifier_DistanceFromCamera;
103                 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
104                         return &RNA_LineStyleColorModifier_DistanceFromObject;
105                 case LS_MODIFIER_MATERIAL:
106                         return &RNA_LineStyleColorModifier_Material;
107                 default:
108                         return &RNA_LineStyleColorModifier;
109         }
110 }
111
112 static StructRNA *rna_LineStyle_alpha_modifier_refine(struct PointerRNA *ptr)
113 {
114         LineStyleModifier *m = (LineStyleModifier *)ptr->data;
115
116         switch (m->type) {
117                 case LS_MODIFIER_ALONG_STROKE:
118                         return &RNA_LineStyleAlphaModifier_AlongStroke;
119                 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
120                         return &RNA_LineStyleAlphaModifier_DistanceFromCamera;
121                 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
122                         return &RNA_LineStyleAlphaModifier_DistanceFromObject;
123                 case LS_MODIFIER_MATERIAL:
124                         return &RNA_LineStyleAlphaModifier_Material;
125                 default:
126                         return &RNA_LineStyleAlphaModifier;
127         }
128 }
129
130 static StructRNA *rna_LineStyle_thickness_modifier_refine(struct PointerRNA *ptr)
131 {
132         LineStyleModifier *m = (LineStyleModifier *)ptr->data;
133
134         switch (m->type) {
135                 case LS_MODIFIER_ALONG_STROKE:
136                         return &RNA_LineStyleThicknessModifier_AlongStroke;
137                 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
138                         return &RNA_LineStyleThicknessModifier_DistanceFromCamera;
139                 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
140                         return &RNA_LineStyleThicknessModifier_DistanceFromObject;
141                 case LS_MODIFIER_MATERIAL:
142                         return &RNA_LineStyleThicknessModifier_Material;
143                 case LS_MODIFIER_CALLIGRAPHY:
144                         return &RNA_LineStyleThicknessModifier_Calligraphy;
145                 default:
146                         return &RNA_LineStyleThicknessModifier;
147         }
148 }
149
150 static StructRNA *rna_LineStyle_geometry_modifier_refine(struct PointerRNA *ptr)
151 {
152         LineStyleModifier *m = (LineStyleModifier *)ptr->data;
153
154         switch (m->type) {
155                 case LS_MODIFIER_SAMPLING:
156                         return &RNA_LineStyleGeometryModifier_Sampling;
157                 case LS_MODIFIER_BEZIER_CURVE:
158                         return &RNA_LineStyleGeometryModifier_BezierCurve;
159                 case LS_MODIFIER_SINUS_DISPLACEMENT:
160                         return &RNA_LineStyleGeometryModifier_SinusDisplacement;
161                 case LS_MODIFIER_SPATIAL_NOISE:
162                         return &RNA_LineStyleGeometryModifier_SpatialNoise;
163                 case LS_MODIFIER_PERLIN_NOISE_1D:
164                         return &RNA_LineStyleGeometryModifier_PerlinNoise1D;
165                 case LS_MODIFIER_PERLIN_NOISE_2D:
166                         return &RNA_LineStyleGeometryModifier_PerlinNoise2D;
167                 case LS_MODIFIER_BACKBONE_STRETCHER:
168                         return &RNA_LineStyleGeometryModifier_BackboneStretcher;
169                 case LS_MODIFIER_TIP_REMOVER:
170                         return &RNA_LineStyleGeometryModifier_TipRemover;
171                 case LS_MODIFIER_POLYGONIZATION:
172                         return &RNA_LineStyleGeometryModifier_Polygonalization;
173                 case LS_MODIFIER_GUIDING_LINES:
174                         return &RNA_LineStyleGeometryModifier_GuidingLines;
175                 case LS_MODIFIER_BLUEPRINT:
176                         return &RNA_LineStyleGeometryModifier_Blueprint;
177                 case LS_MODIFIER_2D_OFFSET:
178                         return &RNA_LineStyleGeometryModifier_2DOffset;
179                 case LS_MODIFIER_2D_TRANSFORM:
180                         return &RNA_LineStyleGeometryModifier_2DTransform;
181                 default:
182                         return &RNA_LineStyleGeometryModifier;
183         }
184 }
185
186 static char *rna_LineStyle_color_modifier_path(PointerRNA *ptr)
187 {
188         LineStyleModifier *m = (LineStyleModifier *)ptr->data;
189         char name_esc[sizeof(m->name) * 2];
190         BLI_strescape(name_esc, m->name, sizeof(name_esc));
191         return BLI_sprintfN("color_modifiers[\"%s\"]", name_esc);
192 }
193
194 static char *rna_LineStyle_alpha_modifier_path(PointerRNA *ptr)
195 {
196         LineStyleModifier *m = (LineStyleModifier *)ptr->data;
197         char name_esc[sizeof(m->name) * 2];
198         BLI_strescape(name_esc, m->name, sizeof(name_esc));
199         return BLI_sprintfN("alpha_modifiers[\"%s\"]", name_esc);
200 }
201
202 static char *rna_LineStyle_thickness_modifier_path(PointerRNA *ptr)
203 {
204         LineStyleModifier *m = (LineStyleModifier *)ptr->data;
205         char name_esc[sizeof(m->name) * 2];
206         BLI_strescape(name_esc, m->name, sizeof(name_esc));
207         return BLI_sprintfN("thickness_modifiers[\"%s\"]", name_esc);
208 }
209
210 static char *rna_LineStyle_geometry_modifier_path(PointerRNA *ptr)
211 {
212         LineStyleModifier *m = (LineStyleModifier *)ptr->data;
213         char name_esc[sizeof(m->name) * 2];
214         BLI_strescape(name_esc, m->name, sizeof(name_esc));
215         return BLI_sprintfN("geometry_modifiers[\"%s\"]", name_esc);
216 }
217
218 static void rna_LineStyleColorModifier_name_set(PointerRNA *ptr, const char *value)
219 {
220         FreestyleLineStyle *linestyle = (FreestyleLineStyle *)ptr->id.data;
221         LineStyleModifier *m = (LineStyleModifier *)ptr->data;
222
223         BLI_strncpy_utf8(m->name, value, sizeof(m->name));
224         BLI_uniquename(&linestyle->color_modifiers, m, "ColorModifier", '.',
225                        offsetof(LineStyleModifier, name), sizeof(m->name));
226 }
227
228 static void rna_LineStyleAlphaModifier_name_set(PointerRNA *ptr, const char *value)
229 {
230         FreestyleLineStyle *linestyle = (FreestyleLineStyle *)ptr->id.data;
231         LineStyleModifier *m = (LineStyleModifier *)ptr->data;
232
233         BLI_strncpy_utf8(m->name, value, sizeof(m->name));
234         BLI_uniquename(&linestyle->alpha_modifiers, m, "AlphaModifier", '.',
235                        offsetof(LineStyleModifier, name), sizeof(m->name));
236 }
237
238 static void rna_LineStyleThicknessModifier_name_set(PointerRNA *ptr, const char *value)
239 {
240         FreestyleLineStyle *linestyle = (FreestyleLineStyle *)ptr->id.data;
241         LineStyleModifier *m = (LineStyleModifier *)ptr->data;
242
243         BLI_strncpy_utf8(m->name, value, sizeof(m->name));
244         BLI_uniquename(&linestyle->thickness_modifiers, m, "ThicknessModifier", '.',
245                        offsetof(LineStyleModifier, name), sizeof(m->name));
246 }
247
248 static void rna_LineStyleGeometryModifier_name_set(PointerRNA *ptr, const char *value)
249 {
250         FreestyleLineStyle *linestyle = (FreestyleLineStyle *)ptr->id.data;
251         LineStyleModifier *m = (LineStyleModifier *)ptr->data;
252
253         BLI_strncpy_utf8(m->name, value, sizeof(m->name));
254         BLI_uniquename(&linestyle->geometry_modifiers, m, "GeometryModifier", '.',
255                        offsetof(LineStyleModifier, name), sizeof(m->name));
256 }
257
258 static void rna_LineStyle_mtex_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
259 {
260         FreestyleLineStyle *linestyle = (FreestyleLineStyle *)ptr->id.data;
261         rna_iterator_array_begin(iter, (void *)linestyle->mtex, sizeof(MTex *), MAX_MTEX, 0, NULL);
262 }
263
264 static PointerRNA rna_LineStyle_active_texture_get(PointerRNA *ptr)
265 {
266         FreestyleLineStyle *linestyle = (FreestyleLineStyle *)ptr->id.data;
267         Tex *tex;
268
269         tex = give_current_linestyle_texture(linestyle);
270         return rna_pointer_inherit_refine(ptr, &RNA_Texture, tex);
271 }
272
273 static void rna_LineStyle_active_texture_set(PointerRNA *ptr, PointerRNA value)
274 {
275         FreestyleLineStyle *linestyle = (FreestyleLineStyle *)ptr->id.data;
276
277         set_current_linestyle_texture(linestyle, value.data);
278 }
279
280 static void rna_LineStyle_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
281 {
282         FreestyleLineStyle *linestyle = ptr->id.data;
283
284         DAG_id_tag_update(&linestyle->id, 0);
285         WM_main_add_notifier(NC_LINESTYLE, linestyle);
286 }
287
288 static void rna_LineStyle_use_nodes_update(bContext *C, PointerRNA *ptr)
289 {
290         FreestyleLineStyle *linestyle = (FreestyleLineStyle *)ptr->data;
291
292         if (linestyle->use_nodes && linestyle->nodetree == NULL)
293                 ED_node_shader_default(C, &linestyle->id);
294
295         rna_LineStyle_update(CTX_data_main(C), CTX_data_scene(C), ptr);
296 }
297
298 static LineStyleModifier *rna_LineStyle_color_modifier_add(FreestyleLineStyle *linestyle, ReportList *reports,
299                                                            const char *name, int type)
300 {
301         LineStyleModifier *modifier = BKE_linestyle_color_modifier_add(linestyle, name, type);
302
303         if (!modifier) {
304                 BKE_report(reports, RPT_ERROR, "Failed to add the color modifier");
305                 return NULL;
306         }
307
308         DAG_id_tag_update(&linestyle->id, 0);
309         WM_main_add_notifier(NC_LINESTYLE, linestyle);
310
311         return modifier;
312 }
313
314 static void rna_LineStyle_color_modifier_remove(FreestyleLineStyle *linestyle, ReportList *reports,
315                                                 PointerRNA *modifier_ptr)
316 {
317         LineStyleModifier *modifier = modifier_ptr->data;
318
319         if (BKE_linestyle_color_modifier_remove(linestyle, modifier) == -1) {
320                 BKE_reportf(reports, RPT_ERROR, "Color modifier '%s' could not be removed", modifier->name);
321                 return;
322         }
323
324         RNA_POINTER_INVALIDATE(modifier_ptr);
325
326         DAG_id_tag_update(&linestyle->id, 0);
327         WM_main_add_notifier(NC_LINESTYLE, linestyle);
328 }
329
330 static LineStyleModifier *rna_LineStyle_alpha_modifier_add(FreestyleLineStyle *linestyle, ReportList *reports,
331                                                            const char *name, int type)
332 {
333         LineStyleModifier *modifier = BKE_linestyle_alpha_modifier_add(linestyle, name, type);
334
335         if (!modifier) {
336                 BKE_report(reports, RPT_ERROR, "Failed to add the alpha modifier");
337                 return NULL;
338         }
339
340         DAG_id_tag_update(&linestyle->id, 0);
341         WM_main_add_notifier(NC_LINESTYLE, linestyle);
342
343         return modifier;
344 }
345
346 static void rna_LineStyle_alpha_modifier_remove(FreestyleLineStyle *linestyle, ReportList *reports,
347                                                 PointerRNA *modifier_ptr)
348 {
349         LineStyleModifier *modifier = modifier_ptr->data;
350
351         if (BKE_linestyle_alpha_modifier_remove(linestyle, modifier) == -1) {
352                 BKE_reportf(reports, RPT_ERROR, "Alpha modifier '%s' could not be removed", modifier->name);
353                 return;
354         }
355
356         RNA_POINTER_INVALIDATE(modifier_ptr);
357
358         DAG_id_tag_update(&linestyle->id, 0);
359         WM_main_add_notifier(NC_LINESTYLE, linestyle);
360 }
361
362 static LineStyleModifier *rna_LineStyle_thickness_modifier_add(FreestyleLineStyle *linestyle, ReportList *reports,
363                                                                const char *name, int type)
364 {
365         LineStyleModifier *modifier = BKE_linestyle_thickness_modifier_add(linestyle, name, type);
366
367         if (!modifier) {
368                 BKE_report(reports, RPT_ERROR, "Failed to add the thickness modifier");
369                 return NULL;
370         }
371
372         DAG_id_tag_update(&linestyle->id, 0);
373         WM_main_add_notifier(NC_LINESTYLE, linestyle);
374
375         return modifier;
376 }
377
378 static void rna_LineStyle_thickness_modifier_remove(FreestyleLineStyle *linestyle, ReportList *reports,
379                                                     PointerRNA *modifier_ptr)
380 {
381         LineStyleModifier *modifier = modifier_ptr->data;
382
383         if (BKE_linestyle_thickness_modifier_remove(linestyle, modifier) == -1) {
384                 BKE_reportf(reports, RPT_ERROR, "Thickness modifier '%s' could not be removed", modifier->name);
385                 return;
386         }
387
388         RNA_POINTER_INVALIDATE(modifier_ptr);
389
390         DAG_id_tag_update(&linestyle->id, 0);
391         WM_main_add_notifier(NC_LINESTYLE, linestyle);
392 }
393
394 static LineStyleModifier *rna_LineStyle_geometry_modifier_add(FreestyleLineStyle *linestyle, ReportList *reports,
395                                                               const char *name, int type)
396 {
397         LineStyleModifier *modifier = BKE_linestyle_geometry_modifier_add(linestyle, name, type);
398
399         if (!modifier) {
400                 BKE_report(reports, RPT_ERROR, "Failed to add the geometry modifier");
401                 return NULL;
402         }
403
404         DAG_id_tag_update(&linestyle->id, 0);
405         WM_main_add_notifier(NC_LINESTYLE, linestyle);
406
407         return modifier;
408 }
409
410 static void rna_LineStyle_geometry_modifier_remove(FreestyleLineStyle *linestyle, ReportList *reports,
411                                                    PointerRNA *modifier_ptr)
412 {
413         LineStyleModifier *modifier = modifier_ptr->data;
414
415         if (BKE_linestyle_geometry_modifier_remove(linestyle, modifier) == -1) {
416                 BKE_reportf(reports, RPT_ERROR, "Geometry modifier '%s' could not be removed", modifier->name);
417                 return;
418         }
419
420         RNA_POINTER_INVALIDATE(modifier_ptr);
421
422         DAG_id_tag_update(&linestyle->id, 0);
423         WM_main_add_notifier(NC_LINESTYLE, linestyle);
424 }
425
426 #else
427
428 #include "BLI_math.h"
429
430 static void rna_def_linestyle_mtex(BlenderRNA *brna)
431 {
432         StructRNA *srna;
433         PropertyRNA *prop;
434
435         static EnumPropertyItem texco_items[] = {
436                 {TEXCO_WINDOW, "WINDOW", 0, "Window", "Use screen coordinates as texture coordinates"},
437                 {TEXCO_GLOB, "GLOBAL", 0, "Global", "Use global coordinates for the texture coordinates"},
438                 {TEXCO_STROKE, "ALONG_STROKE", 0, "Along stroke", "Use stroke length for texture coordinates"},
439                 {TEXCO_ORCO, "ORCO", 0, "Generated", "Use the original undeformed coordinates of the object"},
440                 {0, NULL, 0, NULL, NULL}
441         };
442
443         static EnumPropertyItem prop_mapping_items[] = {
444                 {MTEX_FLAT, "FLAT", 0, "Flat", "Map X and Y coordinates directly"},
445                 {MTEX_CUBE, "CUBE", 0, "Cube", "Map using the normal vector"},
446                 {MTEX_TUBE, "TUBE", 0, "Tube", "Map with Z as central axis"},
447                 {MTEX_SPHERE, "SPHERE", 0, "Sphere", "Map with Z as central axis"},
448                 {0, NULL, 0, NULL, NULL}
449         };
450
451         static EnumPropertyItem prop_x_mapping_items[] = {
452                 {0, "NONE", 0, "None", ""},
453                 {1, "X", 0, "X", ""},
454                 {2, "Y", 0, "Y", ""},
455                 {3, "Z", 0, "Z", ""},
456                 {0, NULL, 0, NULL, NULL}
457         };
458
459         static EnumPropertyItem prop_y_mapping_items[] = {
460                 {0, "NONE", 0, "None", ""},
461                 {1, "X", 0, "X", ""},
462                 {2, "Y", 0, "Y", ""},
463                 {3, "Z", 0, "Z", ""},
464                 {0, NULL, 0, NULL, NULL}
465         };
466
467         static EnumPropertyItem prop_z_mapping_items[] = {
468                 {0, "NONE", 0, "None", ""},
469                 {1, "X", 0, "X", ""},
470                 {2, "Y", 0, "Y", ""},
471                 {3, "Z", 0, "Z", ""},
472                 {0, NULL, 0, NULL, NULL}
473         };
474
475         srna = RNA_def_struct(brna, "LineStyleTextureSlot", "TextureSlot");
476         RNA_def_struct_sdna(srna, "MTex");
477         RNA_def_struct_ui_text(srna, "LineStyle Texture Slot", "Texture slot for textures in a LineStyle datablock");
478
479         prop = RNA_def_property(srna, "mapping_x", PROP_ENUM, PROP_NONE);
480         RNA_def_property_enum_sdna(prop, NULL, "projx");
481         RNA_def_property_enum_items(prop, prop_x_mapping_items);
482         RNA_def_property_ui_text(prop, "X Mapping", "");
483         RNA_def_property_update(prop, 0, "rna_LineStyle_update");
484
485         prop = RNA_def_property(srna, "mapping_y", PROP_ENUM, PROP_NONE);
486         RNA_def_property_enum_sdna(prop, NULL, "projy");
487         RNA_def_property_enum_items(prop, prop_y_mapping_items);
488         RNA_def_property_ui_text(prop, "Y Mapping", "");
489         RNA_def_property_update(prop, 0, "rna_LineStyle_update");
490
491         prop = RNA_def_property(srna, "mapping_z", PROP_ENUM, PROP_NONE);
492         RNA_def_property_enum_sdna(prop, NULL, "projz");
493         RNA_def_property_enum_items(prop, prop_z_mapping_items);
494         RNA_def_property_ui_text(prop, "Z Mapping", "");
495         RNA_def_property_update(prop, 0, "rna_LineStyle_update");
496
497         prop = RNA_def_property(srna, "mapping", PROP_ENUM, PROP_NONE);
498         RNA_def_property_enum_items(prop, prop_mapping_items);
499         RNA_def_property_ui_text(prop, "Mapping", "");
500         RNA_def_property_update(prop, 0, "rna_LineStyle_update");
501
502         /* map to */
503         prop = RNA_def_property(srna, "use_map_color_diffuse", PROP_BOOLEAN, PROP_NONE);
504         RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_COL);
505         RNA_def_property_ui_text(prop, "Diffuse Color", "The texture affects basic color of the stroke");
506         RNA_def_property_update(prop, 0, "rna_LineStyle_update");
507
508         prop = RNA_def_property(srna, "use_map_alpha", PROP_BOOLEAN, PROP_NONE);
509         RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_ALPHA);
510         RNA_def_property_ui_text(prop, "Alpha", "The texture affects the alpha value");
511         RNA_def_property_update(prop, 0, "rna_LineStyle_update");
512
513         prop = RNA_def_property(srna, "use_tips", PROP_BOOLEAN, PROP_NONE);
514         RNA_def_property_boolean_sdna(prop, NULL, "texflag", MTEX_TIPS);
515         RNA_def_property_ui_text(prop, "Use Tips", "Lower half of the texture is for tips of the stroke");
516         RNA_def_property_update(prop, 0, "rna_LineStyle_update");
517
518         prop = RNA_def_property(srna, "texture_coords", PROP_ENUM, PROP_NONE);
519         RNA_def_property_enum_sdna(prop, NULL, "texco");
520         RNA_def_property_enum_items(prop, texco_items);
521         RNA_def_property_ui_text(prop, "Texture Coordinates",
522                                  "Texture coordinates used to map the texture onto the background");
523         RNA_def_property_update(prop, 0, "rna_LineStyle_update");
524
525         prop = RNA_def_property(srna, "alpha_factor", PROP_FLOAT, PROP_NONE);
526         RNA_def_property_float_sdna(prop, NULL, "alphafac");
527         RNA_def_property_ui_range(prop, -1, 1, 10, 3);
528         RNA_def_property_ui_text(prop, "Alpha Factor", "Amount texture affects alpha");
529         RNA_def_property_update(prop, 0, "rna_LineStyle_update");
530
531         prop = RNA_def_property(srna, "diffuse_color_factor", PROP_FLOAT, PROP_NONE);
532         RNA_def_property_float_sdna(prop, NULL, "colfac");
533         RNA_def_property_ui_range(prop, 0, 1, 10, 3);
534         RNA_def_property_ui_text(prop, "Diffuse Color Factor", "Amount texture affects diffuse color");
535         RNA_def_property_update(prop, 0, "rna_LineStyle_update");
536 }
537
538 static void rna_def_modifier_type_common(StructRNA *srna, EnumPropertyItem *modifier_type_items,
539                                          const char *set_name_func, const bool blend, const bool color)
540 {
541         PropertyRNA *prop;
542
543         /* TODO: Check this is not already defined somewhere else, e.g. in nodes... */
544         static EnumPropertyItem value_blend_items[] = {
545                 {LS_VALUE_BLEND, "MIX", 0, "Mix", ""},
546                 {LS_VALUE_ADD, "ADD", 0, "Add", ""},
547                 {LS_VALUE_SUB, "SUBTRACT", 0, "Subtract", ""},
548                 {LS_VALUE_MULT, "MULTIPLY", 0, "Multiply", ""},
549                 {LS_VALUE_DIV, "DIVIDE", 0, "Divide", ""},
550                 {LS_VALUE_DIFF, "DIFFERENCE", 0, "Difference", ""},
551                 {LS_VALUE_MIN, "MININUM", 0, "Minimum", ""}, 
552                 {LS_VALUE_MAX, "MAXIMUM", 0, "Maximum", ""}, 
553                 {0, NULL, 0, NULL, NULL}
554         };
555
556         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
557         RNA_def_property_enum_sdna(prop, NULL, "modifier.type");
558         RNA_def_property_enum_items(prop, modifier_type_items);
559         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
560         RNA_def_property_ui_text(prop, "Modifier Type", "Type of the modifier");
561
562         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
563         RNA_def_property_string_sdna(prop, NULL, "modifier.name");
564         RNA_def_property_string_funcs(prop, NULL, NULL, set_name_func);
565         RNA_def_property_ui_text(prop, "Modifier Name", "Name of the modifier");
566         RNA_def_property_update(prop, NC_LINESTYLE, NULL);
567         RNA_def_struct_name_property(srna, prop);
568
569         if (blend) {
570                 prop = RNA_def_property(srna, "blend", PROP_ENUM, PROP_NONE);
571                 RNA_def_property_enum_sdna(prop, NULL, "modifier.blend");
572                 RNA_def_property_enum_items(prop, (color) ? ramp_blend_items : value_blend_items);
573                 RNA_def_property_ui_text(prop, "Blend", "Specify how the modifier value is blended into the base value");
574                 RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
575
576                 prop = RNA_def_property(srna, "influence", PROP_FLOAT, PROP_FACTOR);
577                 RNA_def_property_float_sdna(prop, NULL, "modifier.influence");
578                 RNA_def_property_range(prop, 0.0f, 1.0f);
579                 RNA_def_property_ui_text(prop, "Influence", "Influence factor by which the modifier changes the property");
580                 RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
581         }
582
583         prop = RNA_def_property(srna, "use", PROP_BOOLEAN, PROP_NONE);
584         RNA_def_property_boolean_sdna(prop, NULL, "modifier.flags", LS_MODIFIER_ENABLED);
585         RNA_def_property_ui_text(prop, "Use", "Enable or disable this modifier during stroke rendering");
586
587         prop = RNA_def_property(srna, "expanded", PROP_BOOLEAN, PROP_NONE);
588         RNA_def_property_boolean_sdna(prop, NULL, "modifier.flags", LS_MODIFIER_EXPANDED);
589         RNA_def_property_ui_text(prop, "Expanded", "True if the modifier tab is expanded");
590 }
591
592 static void rna_def_color_modifier(StructRNA *srna)
593 {
594         rna_def_modifier_type_common(srna, linestyle_color_modifier_type_items,
595                                      "rna_LineStyleColorModifier_name_set", true, true);
596 }
597
598 static void rna_def_alpha_modifier(StructRNA *srna)
599 {
600         rna_def_modifier_type_common(srna, linestyle_alpha_modifier_type_items,
601                                      "rna_LineStyleAlphaModifier_name_set", true, false);
602 }
603
604 static void rna_def_thickness_modifier(StructRNA *srna)
605 {
606         rna_def_modifier_type_common(srna, linestyle_thickness_modifier_type_items,
607                                      "rna_LineStyleThicknessModifier_name_set", true, false);
608 }
609
610 static void rna_def_geometry_modifier(StructRNA *srna)
611 {
612         rna_def_modifier_type_common(srna, linestyle_geometry_modifier_type_items,
613                                      "rna_LineStyleGeometryModifier_name_set", false, false);
614 }
615
616 static void rna_def_modifier_color_ramp_common(StructRNA *srna, int range)
617 {
618         PropertyRNA *prop;
619
620         prop = RNA_def_property(srna, "color_ramp", PROP_POINTER, PROP_NONE);
621         RNA_def_property_pointer_sdna(prop, NULL, "color_ramp");
622         RNA_def_property_struct_type(prop, "ColorRamp");
623         RNA_def_property_ui_text(prop, "Color Ramp", "Color ramp used to change line color");
624         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
625
626         if (range) {
627                 prop = RNA_def_property(srna, "range_min", PROP_FLOAT, PROP_DISTANCE);
628                 RNA_def_property_float_sdna(prop, NULL, "range_min");
629                 RNA_def_property_ui_text(prop, "Range Min", "Lower bound of the input range the mapping is applied");
630                 RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
631
632                 prop = RNA_def_property(srna, "range_max", PROP_FLOAT, PROP_DISTANCE);
633                 RNA_def_property_float_sdna(prop, NULL, "range_max");
634                 RNA_def_property_ui_text(prop, "Range Max", "Upper bound of the input range the mapping is applied");
635                 RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
636         }
637 }
638
639 static void rna_def_modifier_curve_common(StructRNA *srna, bool range, bool value)
640 {
641         PropertyRNA *prop;
642
643         static EnumPropertyItem mapping_items[] = {
644                 {0, "LINEAR", 0, "Linear", "Use linear mapping"},
645                 {LS_MODIFIER_USE_CURVE, "CURVE", 0, "Curve", "Use curve mapping"},
646                 {0, NULL, 0, NULL, NULL}
647         };
648
649         prop = RNA_def_property(srna, "mapping", PROP_ENUM, PROP_NONE);
650         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flags");
651         RNA_def_property_enum_items(prop, mapping_items);
652         RNA_def_property_ui_text(prop, "Mapping", "Select the mapping type");
653         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
654
655         prop = RNA_def_property(srna, "invert", PROP_BOOLEAN, PROP_NONE);
656         RNA_def_property_boolean_sdna(prop, NULL, "flags", LS_MODIFIER_INVERT);
657         RNA_def_property_ui_text(prop, "Invert", "Invert the fade-out direction of the linear mapping");
658         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
659
660         prop = RNA_def_property(srna, "curve", PROP_POINTER, PROP_NONE);
661         RNA_def_property_pointer_sdna(prop, NULL, "curve");
662         RNA_def_property_struct_type(prop, "CurveMapping");
663         RNA_def_property_ui_text(prop, "Curve", "Curve used for the curve mapping");
664         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
665
666         if (range) {
667                 prop = RNA_def_property(srna, "range_min", PROP_FLOAT, PROP_DISTANCE);
668                 RNA_def_property_float_sdna(prop, NULL, "range_min");
669                 RNA_def_property_ui_text(prop, "Range Min", "Lower bound of the input range the mapping is applied");
670                 RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
671
672                 prop = RNA_def_property(srna, "range_max", PROP_FLOAT, PROP_DISTANCE);
673                 RNA_def_property_float_sdna(prop, NULL, "range_max");
674                 RNA_def_property_ui_text(prop, "Range Max", "Upper bound of the input range the mapping is applied");
675                 RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
676         }
677
678         if (value) {
679                 prop = RNA_def_property(srna, "value_min", PROP_FLOAT, PROP_NONE);
680                 RNA_def_property_float_sdna(prop, NULL, "value_min");
681                 RNA_def_property_ui_text(prop, "Value Min", "Minimum output value of the mapping");
682                 RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
683
684                 prop = RNA_def_property(srna, "value_max", PROP_FLOAT, PROP_NONE);
685                 RNA_def_property_float_sdna(prop, NULL, "value_max");
686                 RNA_def_property_ui_text(prop, "Value Max", "Maximum output value of the mapping");
687                 RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
688         }
689 }
690
691 static void rna_def_modifier_material_common(StructRNA *srna)
692 {
693         PropertyRNA *prop;
694
695         static EnumPropertyItem mat_attr_items[] = {
696                 {LS_MODIFIER_MATERIAL_LINE, "LINE", 0, "Line Color", ""},
697                 {LS_MODIFIER_MATERIAL_LINE_R, "LINE_R", 0, "Line Color Red", ""},
698                 {LS_MODIFIER_MATERIAL_LINE_G, "LINE_G", 0, "Line Color Green", ""},
699                 {LS_MODIFIER_MATERIAL_LINE_B, "LINE_B", 0, "Line Color Blue", ""},
700                 {LS_MODIFIER_MATERIAL_DIFF, "DIFF", 0, "Diffuse Color", ""},
701                 {LS_MODIFIER_MATERIAL_DIFF_R, "DIFF_R", 0, "Diffuse Color Red", ""},
702                 {LS_MODIFIER_MATERIAL_DIFF_G, "DIFF_G", 0, "Diffuse Color Green", ""},
703                 {LS_MODIFIER_MATERIAL_DIFF_B, "DIFF_B", 0, "Diffuse Color Blue", ""},
704                 {LS_MODIFIER_MATERIAL_SPEC, "SPEC", 0, "Specular Color", ""},
705                 {LS_MODIFIER_MATERIAL_SPEC_R, "SPEC_R", 0, "Specular Color Red", ""},
706                 {LS_MODIFIER_MATERIAL_SPEC_G, "SPEC_G", 0, "Specular Color Green", ""},
707                 {LS_MODIFIER_MATERIAL_SPEC_B, "SPEC_B", 0, "Specular Color Blue", ""},
708                 {LS_MODIFIER_MATERIAL_SPEC_HARD, "SPEC_HARD", 0, "Specular Hardness", ""},
709                 {LS_MODIFIER_MATERIAL_ALPHA, "ALPHA", 0, "Alpha Transparency", ""},
710                 {0, NULL, 0, NULL, NULL}
711         };
712
713         prop = RNA_def_property(srna, "material_attribute", PROP_ENUM, PROP_NONE);
714         RNA_def_property_enum_sdna(prop, NULL, "mat_attr");
715         RNA_def_property_enum_items(prop, mat_attr_items);
716         RNA_def_property_ui_text(prop, "Material Attribute", "Specify which material attribute is used");
717         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
718
719 }
720
721 static void rna_def_linestyle_modifiers(BlenderRNA *brna)
722 {
723         StructRNA *srna;
724         PropertyRNA *prop;
725
726         static EnumPropertyItem blueprint_shape_items[] = {
727                 {LS_MODIFIER_BLUEPRINT_CIRCLES, "CIRCLES", 0, "Circles", "Draw a blueprint using circular contour strokes"},
728                 {LS_MODIFIER_BLUEPRINT_ELLIPSES, "ELLIPSES", 0, "Ellipses", "Draw a blueprint using elliptic contour strokes"},
729                 {LS_MODIFIER_BLUEPRINT_SQUARES, "SQUARES", 0, "Squares", "Draw a blueprint using square contour strokes"},
730                 {0, NULL, 0, NULL, NULL}
731         };
732
733         static EnumPropertyItem transform_pivot_items[] = {
734                 {LS_MODIFIER_2D_TRANSFORM_PIVOT_CENTER, "CENTER", 0, "Stroke Center", ""},
735                 {LS_MODIFIER_2D_TRANSFORM_PIVOT_START, "START", 0, "Stroke Start", ""},
736                 {LS_MODIFIER_2D_TRANSFORM_PIVOT_END, "END", 0, "Stroke End", ""},
737                 {LS_MODIFIER_2D_TRANSFORM_PIVOT_PARAM, "PARAM", 0, "Stroke Point Parameter", ""},
738                 {LS_MODIFIER_2D_TRANSFORM_PIVOT_ABSOLUTE, "ABSOLUTE", 0, "Absolute 2D Point", ""},
739                 {0, NULL, 0, NULL, NULL}
740         };
741
742         srna = RNA_def_struct(brna, "LineStyleModifier", NULL);
743         RNA_def_struct_ui_text(srna, "Line Style Modifier", "Base type to define modifiers");
744
745         /* line color modifiers */
746
747         srna = RNA_def_struct(brna, "LineStyleColorModifier", "LineStyleModifier");
748         RNA_def_struct_sdna(srna, "LineStyleModifier");
749         RNA_def_struct_refine_func(srna, "rna_LineStyle_color_modifier_refine");
750         RNA_def_struct_path_func(srna, "rna_LineStyle_color_modifier_path");
751         RNA_def_struct_ui_text(srna, "Line Style Color Modifier", "Base type to define line color modifiers");
752
753         srna = RNA_def_struct(brna, "LineStyleColorModifier_AlongStroke", "LineStyleColorModifier");
754         RNA_def_struct_ui_text(srna, "Along Stroke", "Change line color along stroke");
755         rna_def_color_modifier(srna);
756         rna_def_modifier_color_ramp_common(srna, false);
757
758         srna = RNA_def_struct(brna, "LineStyleColorModifier_DistanceFromCamera", "LineStyleColorModifier");
759         RNA_def_struct_ui_text(srna, "Distance from Camera", "Change line color based on the distance from the camera");
760         rna_def_color_modifier(srna);
761         rna_def_modifier_color_ramp_common(srna, true);
762
763         srna = RNA_def_struct(brna, "LineStyleColorModifier_DistanceFromObject", "LineStyleColorModifier");
764         RNA_def_struct_ui_text(srna, "Distance from Object", "Change line color based on the distance from an object");
765         rna_def_color_modifier(srna);
766         rna_def_modifier_color_ramp_common(srna, true);
767
768         prop = RNA_def_property(srna, "target", PROP_POINTER, PROP_NONE);
769         RNA_def_property_pointer_sdna(prop, NULL, "target");
770         RNA_def_property_struct_type(prop, "Object");
771         RNA_def_property_flag(prop, PROP_EDITABLE);
772         RNA_def_property_ui_text(prop, "Target", "Target object from which the distance is measured");
773         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
774
775         srna = RNA_def_struct(brna, "LineStyleColorModifier_Material", "LineStyleColorModifier");
776         RNA_def_struct_ui_text(srna, "Material", "Change line color based on a material attribute");
777         rna_def_color_modifier(srna);
778         rna_def_modifier_material_common(srna);
779         rna_def_modifier_color_ramp_common(srna, false);
780
781         prop = RNA_def_property(srna, "use_ramp", PROP_BOOLEAN, PROP_NONE);
782         RNA_def_property_boolean_sdna(prop, NULL, "flags", LS_MODIFIER_USE_RAMP);
783         RNA_def_property_ui_text(prop, "Ramp", "Use color ramp to map the BW average into an RGB color");
784         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
785
786         /* alpha transparency modifiers */
787
788         srna = RNA_def_struct(brna, "LineStyleAlphaModifier", "LineStyleModifier");
789         RNA_def_struct_sdna(srna, "LineStyleModifier");
790         RNA_def_struct_refine_func(srna, "rna_LineStyle_alpha_modifier_refine");
791         RNA_def_struct_path_func(srna, "rna_LineStyle_alpha_modifier_path");
792         RNA_def_struct_ui_text(srna, "Line Style Alpha Modifier", "Base type to define alpha transparency modifiers");
793
794         srna = RNA_def_struct(brna, "LineStyleAlphaModifier_AlongStroke", "LineStyleAlphaModifier");
795         RNA_def_struct_ui_text(srna, "Along Stroke", "Change alpha transparency along stroke");
796         rna_def_alpha_modifier(srna);
797         rna_def_modifier_curve_common(srna, false, false);
798
799         srna = RNA_def_struct(brna, "LineStyleAlphaModifier_DistanceFromCamera", "LineStyleAlphaModifier");
800         RNA_def_struct_ui_text(srna, "Distance from Camera",
801                                "Change alpha transparency based on the distance from the camera");
802         rna_def_alpha_modifier(srna);
803         rna_def_modifier_curve_common(srna, true, false);
804
805         srna = RNA_def_struct(brna, "LineStyleAlphaModifier_DistanceFromObject", "LineStyleAlphaModifier");
806         RNA_def_struct_ui_text(srna, "Distance from Object",
807                                "Change alpha transparency based on the distance from an object");
808         rna_def_alpha_modifier(srna);
809         rna_def_modifier_curve_common(srna, true, false);
810
811         prop = RNA_def_property(srna, "target", PROP_POINTER, PROP_NONE);
812         RNA_def_property_pointer_sdna(prop, NULL, "target");
813         RNA_def_property_struct_type(prop, "Object");
814         RNA_def_property_flag(prop, PROP_EDITABLE);
815         RNA_def_property_ui_text(prop, "Target", "Target object from which the distance is measured");
816         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
817
818         srna = RNA_def_struct(brna, "LineStyleAlphaModifier_Material", "LineStyleAlphaModifier");
819         RNA_def_struct_ui_text(srna, "Material", "Change alpha transparency based on a material attribute");
820         rna_def_alpha_modifier(srna);
821         rna_def_modifier_material_common(srna);
822         rna_def_modifier_curve_common(srna, false, false);
823
824         /* line thickness modifiers */
825
826         srna = RNA_def_struct(brna, "LineStyleThicknessModifier", "LineStyleModifier");
827         RNA_def_struct_sdna(srna, "LineStyleModifier");
828         RNA_def_struct_refine_func(srna, "rna_LineStyle_thickness_modifier_refine");
829         RNA_def_struct_path_func(srna, "rna_LineStyle_thickness_modifier_path");
830         RNA_def_struct_ui_text(srna, "Line Style Thickness Modifier", "Base type to define line thickness modifiers");
831
832         srna = RNA_def_struct(brna, "LineStyleThicknessModifier_AlongStroke", "LineStyleThicknessModifier");
833         RNA_def_struct_ui_text(srna, "Along Stroke", "Change line thickness along stroke");
834         rna_def_thickness_modifier(srna);
835         rna_def_modifier_curve_common(srna, false, true);
836
837         srna = RNA_def_struct(brna, "LineStyleThicknessModifier_DistanceFromCamera", "LineStyleThicknessModifier");
838         RNA_def_struct_ui_text(srna, "Distance from Camera", "Change line thickness based on the distance from the camera");
839         rna_def_thickness_modifier(srna);
840         rna_def_modifier_curve_common(srna, true, true);
841
842         srna = RNA_def_struct(brna, "LineStyleThicknessModifier_DistanceFromObject", "LineStyleThicknessModifier");
843         RNA_def_struct_ui_text(srna, "Distance from Object", "Change line thickness based on the distance from an object");
844         rna_def_thickness_modifier(srna);
845         rna_def_modifier_curve_common(srna, true, true);
846
847         prop = RNA_def_property(srna, "target", PROP_POINTER, PROP_NONE);
848         RNA_def_property_pointer_sdna(prop, NULL, "target");
849         RNA_def_property_struct_type(prop, "Object");
850         RNA_def_property_flag(prop, PROP_EDITABLE);
851         RNA_def_property_ui_text(prop, "Target", "Target object from which the distance is measured");
852         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
853
854         srna = RNA_def_struct(brna, "LineStyleThicknessModifier_Material", "LineStyleThicknessModifier");
855         RNA_def_struct_ui_text(srna, "Material", "Change line thickness based on a material attribute");
856         rna_def_thickness_modifier(srna);
857         rna_def_modifier_material_common(srna);
858         rna_def_modifier_curve_common(srna, false, true);
859
860         srna = RNA_def_struct(brna, "LineStyleThicknessModifier_Calligraphy", "LineStyleThicknessModifier");
861         RNA_def_struct_ui_text(srna, "Calligraphy",
862                                "Change line thickness so that stroke looks like made with a calligraphic pen");
863         rna_def_thickness_modifier(srna);
864
865         prop = RNA_def_property(srna, "orientation", PROP_FLOAT, PROP_ANGLE);
866         RNA_def_property_float_sdna(prop, NULL, "orientation");
867         RNA_def_property_ui_text(prop, "Orientation", "Angle of the main direction");
868         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
869
870         prop = RNA_def_property(srna, "thickness_min", PROP_FLOAT, PROP_NONE);
871         RNA_def_property_float_sdna(prop, NULL, "min_thickness");
872         RNA_def_property_range(prop, 0.0f, 10000.0f);
873         RNA_def_property_ui_text(prop, "Min Thickness",
874                                  "Minimum thickness in the direction perpendicular to the main direction");
875         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
876
877         prop = RNA_def_property(srna, "thickness_max", PROP_FLOAT, PROP_NONE);
878         RNA_def_property_float_sdna(prop, NULL, "max_thickness");
879         RNA_def_property_range(prop, 0.0f, 10000.0f);
880         RNA_def_property_ui_text(prop, "Max Thickness", "Maximum thickness in the main direction");
881         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
882
883         /* geometry modifiers */
884
885         srna = RNA_def_struct(brna, "LineStyleGeometryModifier", "LineStyleModifier");
886         RNA_def_struct_sdna(srna, "LineStyleModifier");
887         RNA_def_struct_refine_func(srna, "rna_LineStyle_geometry_modifier_refine");
888         RNA_def_struct_path_func(srna, "rna_LineStyle_geometry_modifier_path");
889         RNA_def_struct_ui_text(srna, "Line Style Geometry Modifier", "Base type to define stroke geometry modifiers");
890
891         srna = RNA_def_struct(brna, "LineStyleGeometryModifier_Sampling", "LineStyleGeometryModifier");
892         RNA_def_struct_ui_text(srna, "Sampling",
893                                "Specify a new sampling value that determines the resolution of stroke polylines");
894         rna_def_geometry_modifier(srna);
895
896         prop = RNA_def_property(srna, "sampling", PROP_FLOAT, PROP_NONE);
897         RNA_def_property_float_sdna(prop, NULL, "sampling");
898         RNA_def_property_range(prop, 0.0f, 10000.0f);
899         RNA_def_property_ui_text(prop, "Sampling", "New sampling value to be used for subsequent modifiers");
900         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
901
902         srna = RNA_def_struct(brna, "LineStyleGeometryModifier_BezierCurve", "LineStyleGeometryModifier");
903         RNA_def_struct_ui_text(srna, "Bezier Curve",
904                                "Replace stroke backbone geometry by a Bezier curve approximation of the "
905                                "original backbone geometry");
906         rna_def_geometry_modifier(srna);
907
908         prop = RNA_def_property(srna, "error", PROP_FLOAT, PROP_NONE);
909         RNA_def_property_float_sdna(prop, NULL, "error");
910         RNA_def_property_ui_text(prop, "Error",
911                                  "Maximum distance allowed between the new Bezier curve and the "
912                                  "original backbone geometry");
913         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
914
915         srna = RNA_def_struct(brna, "LineStyleGeometryModifier_SinusDisplacement", "LineStyleGeometryModifier");
916         RNA_def_struct_ui_text(srna, "Sinus Displacement", "Add sinus displacement to stroke backbone geometry");
917         rna_def_geometry_modifier(srna);
918
919         prop = RNA_def_property(srna, "wavelength", PROP_FLOAT, PROP_NONE);
920         RNA_def_property_float_sdna(prop, NULL, "wavelength");
921         RNA_def_property_ui_text(prop, "Wavelength", "Wavelength of the sinus displacement");
922         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
923
924         prop = RNA_def_property(srna, "amplitude", PROP_FLOAT, PROP_NONE);
925         RNA_def_property_float_sdna(prop, NULL, "amplitude");
926         RNA_def_property_ui_text(prop, "Amplitude", "Amplitude of the sinus displacement");
927         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
928
929         prop = RNA_def_property(srna, "phase", PROP_FLOAT, PROP_NONE);
930         RNA_def_property_float_sdna(prop, NULL, "phase");
931         RNA_def_property_ui_text(prop, "Phase", "Phase of the sinus displacement");
932         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
933
934         srna = RNA_def_struct(brna, "LineStyleGeometryModifier_SpatialNoise", "LineStyleGeometryModifier");
935         RNA_def_struct_ui_text(srna, "Spatial Noise", "Add spatial noise to stroke backbone geometry");
936         rna_def_geometry_modifier(srna);
937
938         prop = RNA_def_property(srna, "amplitude", PROP_FLOAT, PROP_NONE);
939         RNA_def_property_float_sdna(prop, NULL, "amplitude");
940         RNA_def_property_ui_text(prop, "Amplitude", "Amplitude of the spatial noise");
941         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
942
943         prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_NONE);
944         RNA_def_property_float_sdna(prop, NULL, "scale");
945         RNA_def_property_ui_text(prop, "Scale", "Scale of the spatial noise");
946         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
947
948         prop = RNA_def_property(srna, "octaves", PROP_INT, PROP_UNSIGNED);
949         RNA_def_property_int_sdna(prop, NULL, "octaves");
950         RNA_def_property_ui_text(prop, "Octaves", "Number of octaves (i.e., the amount of detail of the spatial noise)");
951         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
952
953         prop = RNA_def_property(srna, "smooth", PROP_BOOLEAN, PROP_NONE);
954         RNA_def_property_boolean_sdna(prop, NULL, "flags", LS_MODIFIER_SPATIAL_NOISE_SMOOTH);
955         RNA_def_property_ui_text(prop, "Smooth", "If true, the spatial noise is smooth");
956         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
957
958         prop = RNA_def_property(srna, "use_pure_random", PROP_BOOLEAN, PROP_NONE);
959         RNA_def_property_boolean_sdna(prop, NULL, "flags", LS_MODIFIER_SPATIAL_NOISE_PURERANDOM);
960         RNA_def_property_ui_text(prop, "Pure Random", "If true, the spatial noise does not show any coherence");
961         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
962
963         srna = RNA_def_struct(brna, "LineStyleGeometryModifier_PerlinNoise1D", "LineStyleGeometryModifier");
964         RNA_def_struct_ui_text(srna, "Perlin Noise 1D", "Add one-dimensional Perlin noise to stroke backbone geometry");
965         rna_def_geometry_modifier(srna);
966
967         prop = RNA_def_property(srna, "frequency", PROP_FLOAT, PROP_NONE);
968         RNA_def_property_float_sdna(prop, NULL, "frequency");
969         RNA_def_property_ui_text(prop, "Frequency", "Frequency of the Perlin noise");
970         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
971
972         prop = RNA_def_property(srna, "amplitude", PROP_FLOAT, PROP_NONE);
973         RNA_def_property_float_sdna(prop, NULL, "amplitude");
974         RNA_def_property_ui_text(prop, "Amplitude", "Amplitude of the Perlin noise");
975         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
976
977         prop = RNA_def_property(srna, "octaves", PROP_INT, PROP_UNSIGNED);
978         RNA_def_property_int_sdna(prop, NULL, "octaves");
979         RNA_def_property_ui_text(prop, "Octaves", "Number of octaves (i.e., the amount of detail of the Perlin noise)");
980         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
981
982         prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
983         RNA_def_property_float_sdna(prop, NULL, "angle");
984         RNA_def_property_ui_text(prop, "Angle", "Displacement direction");
985         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
986
987         prop = RNA_def_property(srna, "seed", PROP_INT, PROP_NONE);
988         RNA_def_property_int_sdna(prop, NULL, "seed");
989         RNA_def_property_ui_text(prop, "Seed",
990                                  "Seed for random number generation (if negative, time is used as a seed instead)");
991         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
992
993         srna = RNA_def_struct(brna, "LineStyleGeometryModifier_PerlinNoise2D", "LineStyleGeometryModifier");
994         RNA_def_struct_ui_text(srna, "Perlin Noise 2D", "Add two-dimensional Perlin noise to stroke backbone geometry");
995         rna_def_geometry_modifier(srna);
996
997         prop = RNA_def_property(srna, "frequency", PROP_FLOAT, PROP_NONE);
998         RNA_def_property_float_sdna(prop, NULL, "frequency");
999         RNA_def_property_ui_text(prop, "Frequency", "Frequency of the Perlin noise");
1000         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1001
1002         prop = RNA_def_property(srna, "amplitude", PROP_FLOAT, PROP_NONE);
1003         RNA_def_property_float_sdna(prop, NULL, "amplitude");
1004         RNA_def_property_ui_text(prop, "Amplitude", "Amplitude of the Perlin noise");
1005         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1006
1007         prop = RNA_def_property(srna, "octaves", PROP_INT, PROP_UNSIGNED);
1008         RNA_def_property_int_sdna(prop, NULL, "octaves");
1009         RNA_def_property_ui_text(prop, "Octaves", "Number of octaves (i.e., the amount of detail of the Perlin noise)");
1010         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1011
1012         prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
1013         RNA_def_property_float_sdna(prop, NULL, "angle");
1014         RNA_def_property_ui_text(prop, "Angle", "Displacement direction");
1015         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1016
1017         prop = RNA_def_property(srna, "seed", PROP_INT, PROP_NONE);
1018         RNA_def_property_int_sdna(prop, NULL, "seed");
1019         RNA_def_property_ui_text(prop, "Seed",
1020                                  "Seed for random number generation (if negative, time is used as a seed instead)");
1021         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1022
1023         srna = RNA_def_struct(brna, "LineStyleGeometryModifier_BackboneStretcher", "LineStyleGeometryModifier");
1024         RNA_def_struct_ui_text(srna, "Backbone Stretcher", "Stretch the beginning and the end of stroke backbone");
1025         rna_def_geometry_modifier(srna);
1026
1027         prop = RNA_def_property(srna, "backbone_length", PROP_FLOAT, PROP_NONE);
1028         RNA_def_property_float_sdna(prop, NULL, "backbone_length");
1029         RNA_def_property_ui_text(prop, "Backbone Length", "Amount of backbone stretching");
1030         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1031
1032         srna = RNA_def_struct(brna, "LineStyleGeometryModifier_TipRemover", "LineStyleGeometryModifier");
1033         RNA_def_struct_ui_text(srna, "Tip Remover",
1034                                "Remove a piece of stroke at the beginning and the end of stroke backbone");
1035         rna_def_geometry_modifier(srna);
1036
1037         prop = RNA_def_property(srna, "tip_length", PROP_FLOAT, PROP_NONE);
1038         RNA_def_property_float_sdna(prop, NULL, "tip_length");
1039         RNA_def_property_ui_text(prop, "Tip Length", "Length of tips to be removed");
1040         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1041
1042         srna = RNA_def_struct(brna, "LineStyleGeometryModifier_Polygonalization", "LineStyleGeometryModifier");
1043         RNA_def_struct_ui_text(srna, "Polygonalization", "Modify the stroke geometry so that it looks more 'polygonal'");
1044         rna_def_geometry_modifier(srna);
1045
1046         prop = RNA_def_property(srna, "error", PROP_FLOAT, PROP_NONE);
1047         RNA_def_property_float_sdna(prop, NULL, "error");
1048         RNA_def_property_ui_text(prop, "Error",
1049                                  "Maximum distance between the original stroke and its polygonal approximation");
1050         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1051
1052         srna = RNA_def_struct(brna, "LineStyleGeometryModifier_GuidingLines", "LineStyleGeometryModifier");
1053         RNA_def_struct_ui_text(srna, "Guiding Lines",
1054                                "Modify the stroke geometry so that it corresponds to its main direction line");
1055         rna_def_geometry_modifier(srna);
1056
1057         prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
1058         RNA_def_property_float_sdna(prop, NULL, "offset");
1059         RNA_def_property_ui_text(prop, "Offset",
1060                                  "Displacement that is applied to the main direction line along its normal");
1061         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1062
1063         srna = RNA_def_struct(brna, "LineStyleGeometryModifier_Blueprint", "LineStyleGeometryModifier");
1064         RNA_def_struct_ui_text(srna, "Blueprint",
1065                                "Produce a blueprint using circular, elliptic, and square contour strokes");
1066         rna_def_geometry_modifier(srna);
1067
1068         prop = RNA_def_property(srna, "shape", PROP_ENUM, PROP_NONE);
1069         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flags");
1070         RNA_def_property_enum_items(prop, blueprint_shape_items);
1071         RNA_def_property_ui_text(prop, "Shape", "Select the shape of blueprint contour strokes");
1072         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1073
1074         prop = RNA_def_property(srna, "rounds", PROP_INT, PROP_UNSIGNED);
1075         RNA_def_property_int_sdna(prop, NULL, "rounds");
1076         RNA_def_property_range(prop, 1, 1000);
1077         RNA_def_property_ui_text(prop, "Rounds", "Number of rounds in contour strokes");
1078         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1079
1080         prop = RNA_def_property(srna, "backbone_length", PROP_FLOAT, PROP_NONE);
1081         RNA_def_property_float_sdna(prop, NULL, "backbone_length");
1082         RNA_def_property_ui_text(prop, "Backbone Length", "Amount of backbone stretching");
1083         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1084
1085         prop = RNA_def_property(srna, "random_radius", PROP_INT, PROP_UNSIGNED);
1086         RNA_def_property_int_sdna(prop, NULL, "random_radius");
1087         RNA_def_property_ui_text(prop, "Random Radius", "Randomness of the radius");
1088         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1089
1090         prop = RNA_def_property(srna, "random_center", PROP_INT, PROP_UNSIGNED);
1091         RNA_def_property_int_sdna(prop, NULL, "random_center");
1092         RNA_def_property_ui_text(prop, "Random Center", "Randomness of the center");
1093         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1094
1095         prop = RNA_def_property(srna, "random_backbone", PROP_INT, PROP_UNSIGNED);
1096         RNA_def_property_int_sdna(prop, NULL, "random_backbone");
1097         RNA_def_property_ui_text(prop, "Random Backbone", "Randomness of the backbone stretching");
1098         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1099
1100         srna = RNA_def_struct(brna, "LineStyleGeometryModifier_2DOffset", "LineStyleGeometryModifier");
1101         RNA_def_struct_ui_text(srna, "2D Offset", "Add two-dimensional offsets to stroke backbone geometry");
1102         rna_def_geometry_modifier(srna);
1103
1104         prop = RNA_def_property(srna, "start", PROP_FLOAT, PROP_NONE);
1105         RNA_def_property_float_sdna(prop, NULL, "start");
1106         RNA_def_property_ui_text(prop, "Start", "Displacement that is applied from the beginning of the stroke");
1107         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1108
1109         prop = RNA_def_property(srna, "end", PROP_FLOAT, PROP_NONE);
1110         RNA_def_property_float_sdna(prop, NULL, "end");
1111         RNA_def_property_ui_text(prop, "End", "Displacement that is applied from the end of the stroke");
1112         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1113
1114         prop = RNA_def_property(srna, "x", PROP_FLOAT, PROP_NONE);
1115         RNA_def_property_float_sdna(prop, NULL, "x");
1116         RNA_def_property_ui_text(prop, "X", "Displacement that is applied to the X coordinates of stroke vertices");
1117         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1118
1119         prop = RNA_def_property(srna, "y", PROP_FLOAT, PROP_NONE);
1120         RNA_def_property_float_sdna(prop, NULL, "y");
1121         RNA_def_property_ui_text(prop, "Y", "Displacement that is applied to the Y coordinates of stroke vertices");
1122         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1123
1124         srna = RNA_def_struct(brna, "LineStyleGeometryModifier_2DTransform", "LineStyleGeometryModifier");
1125         RNA_def_struct_ui_text(srna, "2D Transform",
1126                                "Apply two-dimensional scaling and rotation to stroke backbone geometry");
1127         rna_def_geometry_modifier(srna);
1128
1129         prop = RNA_def_property(srna, "pivot", PROP_ENUM, PROP_NONE);
1130         RNA_def_property_enum_sdna(prop, NULL, "pivot");
1131         RNA_def_property_enum_items(prop, transform_pivot_items);
1132         RNA_def_property_ui_text(prop, "Pivot", "Pivot of scaling and rotation operations");
1133         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1134
1135         prop = RNA_def_property(srna, "scale_x", PROP_FLOAT, PROP_NONE);
1136         RNA_def_property_float_sdna(prop, NULL, "scale_x");
1137         RNA_def_property_flag(prop, PROP_PROPORTIONAL);
1138         RNA_def_property_ui_text(prop, "Scale X", "Scaling factor that is applied along the X axis");
1139         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1140
1141         prop = RNA_def_property(srna, "scale_y", PROP_FLOAT, PROP_NONE);
1142         RNA_def_property_float_sdna(prop, NULL, "scale_y");
1143         RNA_def_property_flag(prop, PROP_PROPORTIONAL);
1144         RNA_def_property_ui_text(prop, "Scale Y", "Scaling factor that is applied along the Y axis");
1145         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1146
1147         prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
1148         RNA_def_property_float_sdna(prop, NULL, "angle");
1149         RNA_def_property_ui_text(prop, "Rotation Angle", "Rotation angle");
1150         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1151
1152         prop = RNA_def_property(srna, "pivot_u", PROP_FLOAT, PROP_FACTOR);
1153         RNA_def_property_float_sdna(prop, NULL, "pivot_u");
1154         RNA_def_property_range(prop, 0.f, 1.f);
1155         RNA_def_property_ui_text(prop, "Stroke Point Parameter",
1156                                  "Pivot in terms of the stroke point parameter u (0 <= u <= 1)");
1157         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1158
1159         prop = RNA_def_property(srna, "pivot_x", PROP_FLOAT, PROP_NONE);
1160         RNA_def_property_float_sdna(prop, NULL, "pivot_x");
1161         RNA_def_property_ui_text(prop, "Pivot X", "2D X coordinate of the absolute pivot");
1162         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1163
1164         prop = RNA_def_property(srna, "pivot_y", PROP_FLOAT, PROP_NONE);
1165         RNA_def_property_float_sdna(prop, NULL, "pivot_y");
1166         RNA_def_property_ui_text(prop, "Pivot Y", "2D Y coordinate of the absolute pivot");
1167         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1168 }
1169
1170 static void rna_def_freestyle_color_modifiers(BlenderRNA *brna, PropertyRNA *cprop)
1171 {
1172         StructRNA *srna;
1173         FunctionRNA *func;
1174         PropertyRNA *parm;
1175
1176         RNA_def_property_srna(cprop, "LineStyleColorModifiers");
1177         srna = RNA_def_struct(brna, "LineStyleColorModifiers", NULL);
1178         RNA_def_struct_sdna(srna, "FreestyleLineStyle");
1179         RNA_def_struct_ui_text(srna, "Color Modifiers", "Color modifiers for changing line colors");
1180
1181         func = RNA_def_function(srna, "new", "rna_LineStyle_color_modifier_add");
1182         RNA_def_function_ui_description(func, "Add a color modifier to line style");
1183         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1184         parm = RNA_def_string(func, "name", "ColorModifier", 0, "", "New name for the color modifier (not unique)");
1185         RNA_def_property_flag(parm, PROP_REQUIRED);
1186         parm = RNA_def_enum(func, "type", linestyle_color_modifier_type_items, 0, "", "Color modifier type to add");
1187         RNA_def_property_flag(parm, PROP_REQUIRED);
1188         parm = RNA_def_pointer(func, "modifier", "LineStyleColorModifier", "", "Newly added color modifier");
1189         RNA_def_function_return(func, parm);
1190
1191         func = RNA_def_function(srna, "remove", "rna_LineStyle_color_modifier_remove");
1192         RNA_def_function_ui_description(func, "Remove a color modifier from line style");
1193         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1194         parm = RNA_def_pointer(func, "modifier", "LineStyleColorModifier", "", "Color modifier to remove");
1195         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1196         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1197 }
1198
1199 static void rna_def_freestyle_alpha_modifiers(BlenderRNA *brna, PropertyRNA *cprop)
1200 {
1201         StructRNA *srna;
1202         FunctionRNA *func;
1203         PropertyRNA *parm;
1204
1205         RNA_def_property_srna(cprop, "LineStyleAlphaModifiers");
1206         srna = RNA_def_struct(brna, "LineStyleAlphaModifiers", NULL);
1207         RNA_def_struct_sdna(srna, "FreestyleLineStyle");
1208         RNA_def_struct_ui_text(srna, "Alpha Modifiers", "Alpha modifiers for changing line alphas");
1209
1210         func = RNA_def_function(srna, "new", "rna_LineStyle_alpha_modifier_add");
1211         RNA_def_function_ui_description(func, "Add a alpha modifier to line style");
1212         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1213         parm = RNA_def_string(func, "name", "AlphaModifier", 0, "", "New name for the alpha modifier (not unique)");
1214         RNA_def_property_flag(parm, PROP_REQUIRED);
1215         parm = RNA_def_enum(func, "type", linestyle_alpha_modifier_type_items, 0, "", "Alpha modifier type to add");
1216         RNA_def_property_flag(parm, PROP_REQUIRED);
1217         parm = RNA_def_pointer(func, "modifier", "LineStyleAlphaModifier", "", "Newly added alpha modifier");
1218         RNA_def_function_return(func, parm);
1219
1220         func = RNA_def_function(srna, "remove", "rna_LineStyle_alpha_modifier_remove");
1221         RNA_def_function_ui_description(func, "Remove a alpha modifier from line style");
1222         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1223         parm = RNA_def_pointer(func, "modifier", "LineStyleAlphaModifier", "", "Alpha modifier to remove");
1224         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1225         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1226 }
1227
1228 static void rna_def_freestyle_thickness_modifiers(BlenderRNA *brna, PropertyRNA *cprop)
1229 {
1230         StructRNA *srna;
1231         FunctionRNA *func;
1232         PropertyRNA *parm;
1233
1234         RNA_def_property_srna(cprop, "LineStyleThicknessModifiers");
1235         srna = RNA_def_struct(brna, "LineStyleThicknessModifiers", NULL);
1236         RNA_def_struct_sdna(srna, "FreestyleLineStyle");
1237         RNA_def_struct_ui_text(srna, "Thickness Modifiers", "Thickness modifiers for changing line thicknesss");
1238
1239         func = RNA_def_function(srna, "new", "rna_LineStyle_thickness_modifier_add");
1240         RNA_def_function_ui_description(func, "Add a thickness modifier to line style");
1241         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1242         parm = RNA_def_string(func, "name", "ThicknessModifier", 0, "", "New name for the thickness modifier (not unique)");
1243         RNA_def_property_flag(parm, PROP_REQUIRED);
1244         parm = RNA_def_enum(func, "type", linestyle_thickness_modifier_type_items, 0, "", "Thickness modifier type to add");
1245         RNA_def_property_flag(parm, PROP_REQUIRED);
1246         parm = RNA_def_pointer(func, "modifier", "LineStyleThicknessModifier", "", "Newly added thickness modifier");
1247         RNA_def_function_return(func, parm);
1248
1249         func = RNA_def_function(srna, "remove", "rna_LineStyle_thickness_modifier_remove");
1250         RNA_def_function_ui_description(func, "Remove a thickness modifier from line style");
1251         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1252         parm = RNA_def_pointer(func, "modifier", "LineStyleThicknessModifier", "", "Thickness modifier to remove");
1253         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1254         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1255 }
1256
1257 static void rna_def_freestyle_geometry_modifiers(BlenderRNA *brna, PropertyRNA *cprop)
1258 {
1259         StructRNA *srna;
1260         FunctionRNA *func;
1261         PropertyRNA *parm;
1262
1263         RNA_def_property_srna(cprop, "LineStyleGeometryModifiers");
1264         srna = RNA_def_struct(brna, "LineStyleGeometryModifiers", NULL);
1265         RNA_def_struct_sdna(srna, "FreestyleLineStyle");
1266         RNA_def_struct_ui_text(srna, "Geometry Modifiers", "Geometry modifiers for changing line geometrys");
1267
1268         func = RNA_def_function(srna, "new", "rna_LineStyle_geometry_modifier_add");
1269         RNA_def_function_ui_description(func, "Add a geometry modifier to line style");
1270         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1271         parm = RNA_def_string(func, "name", "GeometryModifier", 0, "", "New name for the geometry modifier (not unique)");
1272         RNA_def_property_flag(parm, PROP_REQUIRED);
1273         parm = RNA_def_enum(func, "type", linestyle_geometry_modifier_type_items, 0, "", "Geometry modifier type to add");
1274         RNA_def_property_flag(parm, PROP_REQUIRED);
1275         parm = RNA_def_pointer(func, "modifier", "LineStyleGeometryModifier", "", "Newly added geometry modifier");
1276         RNA_def_function_return(func, parm);
1277
1278         func = RNA_def_function(srna, "remove", "rna_LineStyle_geometry_modifier_remove");
1279         RNA_def_function_ui_description(func, "Remove a geometry modifier from line style");
1280         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1281         parm = RNA_def_pointer(func, "modifier", "LineStyleGeometryModifier", "", "Geometry modifier to remove");
1282         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
1283         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
1284 }
1285
1286 static void rna_def_linestyle(BlenderRNA *brna)
1287 {
1288         StructRNA *srna;
1289         PropertyRNA *prop;
1290
1291         static EnumPropertyItem panel_items[] = {
1292                 {LS_PANEL_STROKES, "STROKES", 0, "Strokes", "Show the panel for stroke construction"},
1293                 {LS_PANEL_COLOR, "COLOR", 0, "Color", "Show the panel for line color options"},
1294                 {LS_PANEL_ALPHA, "ALPHA", 0, "Alpha", "Show the panel for alpha transparency options"},
1295                 {LS_PANEL_THICKNESS, "THICKNESS", 0, "Thickness", "Show the panel for line thickness options"},
1296                 {LS_PANEL_GEOMETRY, "GEOMETRY", 0, "Geometry", "Show the panel for stroke geometry options"},
1297                 {LS_PANEL_TEXTURE, "TEXTURE", 0, "Texture", "Show the panel for stroke texture options"},
1298 #if 0 /* hidden for now */
1299                 {LS_PANEL_MISC, "MISC", 0, "Misc", "Show the panel for miscellaneous options"},
1300 #endif
1301                 {0, NULL, 0, NULL, NULL}
1302         };
1303         static EnumPropertyItem chaining_items[] = {
1304                 {LS_CHAINING_PLAIN, "PLAIN", 0, "Plain", "Plain chaining"},
1305                 {LS_CHAINING_SKETCHY, "SKETCHY", 0, "Sketchy", "Sketchy chaining with a multiple touch"},
1306                 {0, NULL, 0, NULL, NULL}
1307         };
1308         static EnumPropertyItem cap_items[] = {
1309                 {LS_CAPS_BUTT, "BUTT", 0, "Butt", "Butt cap (flat)"},
1310                 {LS_CAPS_ROUND, "ROUND", 0, "Round", "Round cap (half-circle)"},
1311                 {LS_CAPS_SQUARE, "SQUARE", 0, "Square", "Square cap (flat and extended)"},
1312                 {0, NULL, 0, NULL, NULL}
1313         };
1314         static EnumPropertyItem thickness_position_items[] = {
1315                 {LS_THICKNESS_CENTER, "CENTER", 0, "Center", "Silhouettes and border edges are centered along stroke geometry"},
1316                 {LS_THICKNESS_INSIDE, "INSIDE", 0, "Inside", "Silhouettes and border edges are drawn inside of stroke geometry"},
1317                 {LS_THICKNESS_OUTSIDE, "OUTSIDE", 0, "Outside", "Silhouettes and border edges are drawn outside of stroke geometry"},
1318                 {LS_THICKNESS_RELATIVE, "RELATIVE", 0, "Relative", "Silhouettes and border edges are shifted by a user-defined ratio"},
1319                 {0, NULL, 0, NULL, NULL}
1320         };
1321         static EnumPropertyItem sort_key_items[] = {
1322                 {LS_SORT_KEY_DISTANCE_FROM_CAMERA, "DISTANCE_FROM_CAMERA", 0, "Distance from Camera", "Sort by distance from camera (closer lines lie on top of further lines)"},
1323                 {LS_SORT_KEY_2D_LENGTH, "2D_LENGTH", 0, "2D Length", "Sort by curvilinear 2D length (longer lines lie on top of shorter lines)"},
1324                 {0, NULL, 0, NULL, NULL}
1325         };
1326         static EnumPropertyItem sort_order_items[] = {
1327                 {0, "DEFAULT", 0, "Default", "Default order of the sort key"},
1328                 {LS_REVERSE_ORDER, "REVERSE", 0, "Reverse", "Reverse order"},
1329                 {0, NULL, 0, NULL, NULL}
1330         };
1331         static EnumPropertyItem integration_type_items[] = {
1332                 {LS_INTEGRATION_MEAN, "MEAN", 0, "Mean", "The value computed for the chain is the mean of the values obtained for chain vertices"},
1333                 {LS_INTEGRATION_MIN, "MIN", 0, "Min", "The value computed for the chain is the minimum of the values obtained for chain vertices"},
1334                 {LS_INTEGRATION_MAX, "MAX", 0, "Max", "The value computed for the chain is the maximum of the values obtained for chain vertices"},
1335                 {LS_INTEGRATION_FIRST, "FIRST", 0, "First", "The value computed for the chain is the value obtained for the first chain vertex"},
1336                 {LS_INTEGRATION_LAST, "LAST", 0, "Last", "The value computed for the chain is the value obtained for the last chain vertex"},
1337                 {0, NULL, 0, NULL, NULL}
1338         };
1339
1340         srna = RNA_def_struct(brna, "FreestyleLineStyle", "ID");
1341         RNA_def_struct_ui_text(srna, "Freestyle Line Style", "Freestyle line style, reusable by multiple line sets");
1342         RNA_def_struct_ui_icon(srna, ICON_LINE_DATA);
1343
1344         rna_def_mtex_common(brna, srna, "rna_LineStyle_mtex_begin", "rna_LineStyle_active_texture_get",
1345                             "rna_LineStyle_active_texture_set", NULL, "LineStyleTextureSlot", "LineStyleTextureSlots",
1346                             "rna_LineStyle_update", "rna_LineStyle_update");
1347
1348         prop = RNA_def_property(srna, "panel", PROP_ENUM, PROP_NONE);
1349         RNA_def_property_enum_bitflag_sdna(prop, NULL, "panel");
1350         RNA_def_property_enum_items(prop, panel_items);
1351         RNA_def_property_ui_text(prop, "Panel", "Select the property panel to be shown");
1352         RNA_def_property_update(prop, NC_LINESTYLE, NULL);
1353
1354         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
1355         RNA_def_property_float_sdna(prop, NULL, "r");
1356         RNA_def_property_array(prop, 3);
1357         RNA_def_property_ui_text(prop, "Color", "Base line color, possibly modified by line color modifiers");
1358         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1359
1360         prop = RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_FACTOR);
1361         RNA_def_property_float_sdna(prop, NULL, "alpha");
1362         RNA_def_property_range(prop, 0.0f, 1.0f);
1363         RNA_def_property_ui_text(prop, "Alpha Transparency",
1364                                  "Base alpha transparency, possibly modified by alpha transparency modifiers");
1365         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1366
1367         prop = RNA_def_property(srna, "thickness", PROP_FLOAT, PROP_NONE);
1368         RNA_def_property_float_sdna(prop, NULL, "thickness");
1369         RNA_def_property_range(prop, 0.0f, 10000.0f);
1370         RNA_def_property_ui_text(prop, "Thickness", "Base line thickness, possibly modified by line thickness modifiers");
1371         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1372
1373         prop = RNA_def_property(srna, "thickness_position", PROP_ENUM, PROP_NONE);
1374         RNA_def_property_enum_bitflag_sdna(prop, NULL, "thickness_position");
1375         RNA_def_property_enum_items(prop, thickness_position_items);
1376         RNA_def_property_ui_text(prop, "Thickness Position",
1377                                        "Thickness position of silhouettes and border edges (applicable when plain chaining is used with the Same Object option)");
1378         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1379
1380         prop = RNA_def_property(srna, "thickness_ratio", PROP_FLOAT, PROP_FACTOR);
1381         RNA_def_property_float_sdna(prop, NULL, "thickness_ratio");
1382         RNA_def_property_range(prop, 0.f, 1.f);
1383         RNA_def_property_ui_text(prop, "Thickness Ratio",
1384                                  "A number between 0 (inside) and 1 (outside) specifying the relative position of "
1385                                  "stroke thickness");
1386         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1387
1388         prop = RNA_def_property(srna, "color_modifiers", PROP_COLLECTION, PROP_NONE);
1389         RNA_def_property_collection_sdna(prop, NULL, "color_modifiers", NULL);
1390         RNA_def_property_struct_type(prop, "LineStyleColorModifier");
1391         RNA_def_property_ui_text(prop, "Color Modifiers", "List of line color modifiers");
1392         rna_def_freestyle_color_modifiers(brna, prop);
1393
1394         prop = RNA_def_property(srna, "alpha_modifiers", PROP_COLLECTION, PROP_NONE);
1395         RNA_def_property_collection_sdna(prop, NULL, "alpha_modifiers", NULL);
1396         RNA_def_property_struct_type(prop, "LineStyleAlphaModifier");
1397         RNA_def_property_ui_text(prop, "Alpha Modifiers", "List of alpha transparency modifiers");
1398         rna_def_freestyle_alpha_modifiers(brna, prop);
1399
1400         prop = RNA_def_property(srna, "thickness_modifiers", PROP_COLLECTION, PROP_NONE);
1401         RNA_def_property_collection_sdna(prop, NULL, "thickness_modifiers", NULL);
1402         RNA_def_property_struct_type(prop, "LineStyleThicknessModifier");
1403         RNA_def_property_ui_text(prop, "Thickness Modifiers", "List of line thickness modifiers");
1404         rna_def_freestyle_thickness_modifiers(brna, prop);
1405
1406         prop = RNA_def_property(srna, "geometry_modifiers", PROP_COLLECTION, PROP_NONE);
1407         RNA_def_property_collection_sdna(prop, NULL, "geometry_modifiers", NULL);
1408         RNA_def_property_struct_type(prop, "LineStyleGeometryModifier");
1409         RNA_def_property_ui_text(prop, "Geometry Modifiers", "List of stroke geometry modifiers");
1410         rna_def_freestyle_geometry_modifiers(brna, prop);
1411
1412         prop = RNA_def_property(srna, "use_chaining", PROP_BOOLEAN, PROP_NONE);
1413         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", LS_NO_CHAINING);
1414         RNA_def_property_ui_text(prop, "Chaining", "Enable chaining of feature edges");
1415         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1416
1417         prop = RNA_def_property(srna, "chaining", PROP_ENUM, PROP_NONE);
1418         RNA_def_property_enum_sdna(prop, NULL, "chaining");
1419         RNA_def_property_enum_items(prop, chaining_items);
1420         RNA_def_property_ui_text(prop, "Chaining Method", "Select the way how feature edges are jointed to form chains");
1421         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1422
1423         prop = RNA_def_property(srna, "rounds", PROP_INT, PROP_UNSIGNED);
1424         RNA_def_property_int_sdna(prop, NULL, "rounds");
1425         RNA_def_property_range(prop, 1, 1000);
1426         RNA_def_property_ui_text(prop, "Rounds", "Number of rounds in a sketchy multiple touch");
1427         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1428
1429         prop = RNA_def_property(srna, "use_same_object", PROP_BOOLEAN, PROP_NONE);
1430         RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_SAME_OBJECT);
1431         RNA_def_property_ui_text(prop, "Same Object", "If true, only feature edges of the same object are joined");
1432         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1433
1434         prop = RNA_def_property(srna, "use_split_length", PROP_BOOLEAN, PROP_NONE);
1435         RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_SPLIT_LENGTH);
1436         RNA_def_property_ui_text(prop, "Use Split Length", "Enable chain splitting by curvilinear 2D length");
1437         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1438
1439         prop = RNA_def_property(srna, "split_length", PROP_FLOAT, PROP_NONE);
1440         RNA_def_property_float_sdna(prop, NULL, "split_length");
1441         RNA_def_property_range(prop, 0.0f, 10000.0f);
1442         RNA_def_property_ui_text(prop, "Split Length", "Curvilinear 2D length for chain splitting");
1443         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1444
1445         prop = RNA_def_property(srna, "use_angle_min", PROP_BOOLEAN, PROP_NONE);
1446         RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_MIN_2D_ANGLE);
1447         RNA_def_property_ui_text(prop, "Use Min 2D Angle",
1448                                  "Split chains at points with angles smaller than the minimum 2D angle");
1449         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1450
1451         prop = RNA_def_property(srna, "angle_min", PROP_FLOAT, PROP_ANGLE);
1452         RNA_def_property_float_sdna(prop, NULL, "min_angle");
1453         RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
1454         RNA_def_property_ui_text(prop, "Min 2D Angle", "Minimum 2D angle for splitting chains");
1455         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1456
1457         prop = RNA_def_property(srna, "use_angle_max", PROP_BOOLEAN, PROP_NONE);
1458         RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_MAX_2D_ANGLE);
1459         RNA_def_property_ui_text(prop, "Use Max 2D Angle",
1460                                  "Split chains at points with angles larger than the maximum 2D angle");
1461         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1462
1463         prop = RNA_def_property(srna, "angle_max", PROP_FLOAT, PROP_ANGLE);
1464         RNA_def_property_float_sdna(prop, NULL, "max_angle");
1465         RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
1466         RNA_def_property_ui_text(prop, "Max 2D Angle", "Maximum 2D angle for splitting chains");
1467         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1468
1469         prop = RNA_def_property(srna, "use_length_min", PROP_BOOLEAN, PROP_NONE);
1470         RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_MIN_2D_LENGTH);
1471         RNA_def_property_ui_text(prop, "Use Min 2D Length", "Enable the selection of chains by a minimum 2D length");
1472         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1473
1474         prop = RNA_def_property(srna, "length_min", PROP_FLOAT, PROP_NONE);
1475         RNA_def_property_float_sdna(prop, NULL, "min_length");
1476         RNA_def_property_range(prop, 0.0f, 10000.0f);
1477         RNA_def_property_ui_text(prop, "Min 2D Length", "Minimum curvilinear 2D length for the selection of chains");
1478         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1479
1480         prop = RNA_def_property(srna, "use_length_max", PROP_BOOLEAN, PROP_NONE);
1481         RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_MAX_2D_LENGTH);
1482         RNA_def_property_ui_text(prop, "Use Max 2D Length", "Enable the selection of chains by a maximum 2D length");
1483         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1484
1485         prop = RNA_def_property(srna, "length_max", PROP_FLOAT, PROP_NONE);
1486         RNA_def_property_float_sdna(prop, NULL, "max_length");
1487         RNA_def_property_range(prop, 0.0f, 10000.0f);
1488         RNA_def_property_ui_text(prop, "Max 2D Length", "Maximum curvilinear 2D length for the selection of chains");
1489         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1490
1491         prop = RNA_def_property(srna, "use_split_pattern", PROP_BOOLEAN, PROP_NONE);
1492         RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_SPLIT_PATTERN);
1493         RNA_def_property_ui_text(prop, "Use Split Pattern", "Enable chain splitting by dashed line patterns");
1494         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1495
1496         prop = RNA_def_property(srna, "split_dash1", PROP_INT, PROP_UNSIGNED);
1497         RNA_def_property_int_sdna(prop, NULL, "split_dash1");
1498         RNA_def_property_range(prop, 0, USHRT_MAX);
1499         RNA_def_property_ui_text(prop, "Split Dash 1", "Length of the 1st dash for splitting");
1500         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1501
1502         prop = RNA_def_property(srna, "split_gap1", PROP_INT, PROP_UNSIGNED);
1503         RNA_def_property_int_sdna(prop, NULL, "split_gap1");
1504         RNA_def_property_range(prop, 0, USHRT_MAX);
1505         RNA_def_property_ui_text(prop, "Split Gap 1", "Length of the 1st gap for splitting");
1506         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1507
1508         prop = RNA_def_property(srna, "split_dash2", PROP_INT, PROP_UNSIGNED);
1509         RNA_def_property_int_sdna(prop, NULL, "split_dash2");
1510         RNA_def_property_range(prop, 0, USHRT_MAX);
1511         RNA_def_property_ui_text(prop, "Split Dash 2", "Length of the 2nd dash for splitting");
1512         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1513
1514         prop = RNA_def_property(srna, "split_gap2", PROP_INT, PROP_UNSIGNED);
1515         RNA_def_property_int_sdna(prop, NULL, "split_gap2");
1516         RNA_def_property_range(prop, 0, USHRT_MAX);
1517         RNA_def_property_ui_text(prop, "Split Gap 2", "Length of the 2nd gap for splitting");
1518         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1519
1520         prop = RNA_def_property(srna, "split_dash3", PROP_INT, PROP_UNSIGNED);
1521         RNA_def_property_int_sdna(prop, NULL, "split_dash3");
1522         RNA_def_property_range(prop, 0, USHRT_MAX);
1523         RNA_def_property_ui_text(prop, "Split Dash 3", "Length of the 3rd dash for splitting");
1524         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1525
1526         prop = RNA_def_property(srna, "split_gap3", PROP_INT, PROP_UNSIGNED);
1527         RNA_def_property_int_sdna(prop, NULL, "split_gap3");
1528         RNA_def_property_range(prop, 0, USHRT_MAX);
1529         RNA_def_property_ui_text(prop, "Split Gap 3", "Length of the 3rd gap for splitting");
1530         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1531
1532         prop = RNA_def_property(srna, "material_boundary", PROP_BOOLEAN, PROP_NONE);
1533         RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_MATERIAL_BOUNDARY);
1534         RNA_def_property_ui_text(prop, "Material Boundary", "If true, chains of feature edges are split at material boundaries");
1535         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1536
1537         prop = RNA_def_property(srna, "use_sorting", PROP_BOOLEAN, PROP_NONE);
1538         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", LS_NO_SORTING);
1539         RNA_def_property_ui_text(prop, "Sorting", "Arrange the stacking order of strokes");
1540         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1541
1542         prop = RNA_def_property(srna, "sort_key", PROP_ENUM, PROP_NONE);
1543         RNA_def_property_enum_sdna(prop, NULL, "sort_key");
1544         RNA_def_property_enum_items(prop, sort_key_items);
1545         RNA_def_property_ui_text(prop, "Sort Key", "Select the sort key to determine the stacking order of chains");
1546         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1547
1548         prop = RNA_def_property(srna, "sort_order", PROP_ENUM, PROP_NONE);
1549         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
1550         RNA_def_property_enum_items(prop, sort_order_items);
1551         RNA_def_property_ui_text(prop, "Sort Order", "Select the sort order");
1552         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1553
1554         prop = RNA_def_property(srna, "integration_type", PROP_ENUM, PROP_NONE);
1555         RNA_def_property_enum_sdna(prop, NULL, "integration_type");
1556         RNA_def_property_enum_items(prop, integration_type_items);
1557         RNA_def_property_ui_text(prop, "Integration Type", "Select the way how the sort key is computed for each chain");
1558         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1559
1560         prop = RNA_def_property(srna, "use_dashed_line", PROP_BOOLEAN, PROP_NONE);
1561         RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_DASHED_LINE);
1562         RNA_def_property_ui_text(prop, "Dashed Line", "Enable or disable dashed line");
1563         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1564
1565         prop = RNA_def_property(srna, "caps", PROP_ENUM, PROP_NONE);
1566         RNA_def_property_enum_bitflag_sdna(prop, NULL, "caps");
1567         RNA_def_property_enum_items(prop, cap_items);
1568         RNA_def_property_ui_text(prop, "Caps", "Select the shape of both ends of strokes");
1569         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1570
1571         prop = RNA_def_property(srna, "dash1", PROP_INT, PROP_UNSIGNED);
1572         RNA_def_property_int_sdna(prop, NULL, "dash1");
1573         RNA_def_property_range(prop, 0, USHRT_MAX);
1574         RNA_def_property_ui_text(prop, "Dash 1", "Length of the 1st dash for dashed lines");
1575         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1576
1577         prop = RNA_def_property(srna, "gap1", PROP_INT, PROP_UNSIGNED);
1578         RNA_def_property_int_sdna(prop, NULL, "gap1");
1579         RNA_def_property_range(prop, 0, USHRT_MAX);
1580         RNA_def_property_ui_text(prop, "Gap 1", "Length of the 1st gap for dashed lines");
1581         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1582
1583         prop = RNA_def_property(srna, "dash2", PROP_INT, PROP_UNSIGNED);
1584         RNA_def_property_int_sdna(prop, NULL, "dash2");
1585         RNA_def_property_range(prop, 0, USHRT_MAX);
1586         RNA_def_property_ui_text(prop, "Dash 2", "Length of the 2nd dash for dashed lines");
1587         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1588
1589         prop = RNA_def_property(srna, "gap2", PROP_INT, PROP_UNSIGNED);
1590         RNA_def_property_int_sdna(prop, NULL, "gap2");
1591         RNA_def_property_range(prop, 0, USHRT_MAX);
1592         RNA_def_property_ui_text(prop, "Gap 2", "Length of the 2nd gap for dashed lines");
1593         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1594
1595         prop = RNA_def_property(srna, "dash3", PROP_INT, PROP_UNSIGNED);
1596         RNA_def_property_int_sdna(prop, NULL, "dash3");
1597         RNA_def_property_range(prop, 0, USHRT_MAX);
1598         RNA_def_property_ui_text(prop, "Dash 3", "Length of the 3rd dash for dashed lines");
1599         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1600
1601         prop = RNA_def_property(srna, "gap3", PROP_INT, PROP_UNSIGNED);
1602         RNA_def_property_int_sdna(prop, NULL, "gap3");
1603         RNA_def_property_range(prop, 0, USHRT_MAX);
1604         RNA_def_property_ui_text(prop, "Gap 3", "Length of the 3rd gap for dashed lines");
1605         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1606
1607         prop = RNA_def_property(srna, "use_texture", PROP_BOOLEAN, PROP_NONE);
1608         RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_TEXTURE);
1609         RNA_def_property_ui_text(prop, "Use Textures", "Enable or disable textured strokes");
1610         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1611
1612         prop = RNA_def_property(srna, "texture_spacing", PROP_FLOAT, PROP_FACTOR);
1613         RNA_def_property_float_sdna(prop, NULL, "texstep");
1614         RNA_def_property_range(prop, 0.01f, 100.0f);
1615         RNA_def_property_ui_text(prop, "Texture spacing", "Spacing for textures along stroke length");
1616         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_update");
1617
1618         /* nodes */
1619         prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
1620         RNA_def_property_pointer_sdna(prop, NULL, "nodetree");
1621         RNA_def_property_ui_text(prop, "Node Tree", "Node tree for node-based shaders");
1622
1623         prop = RNA_def_property(srna, "use_nodes", PROP_BOOLEAN, PROP_NONE);
1624         RNA_def_property_boolean_sdna(prop, NULL, "use_nodes", 1);
1625         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1626         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
1627         RNA_def_property_ui_text(prop, "Use Nodes", "Use shader nodes for the line style");
1628         RNA_def_property_update(prop, NC_LINESTYLE, "rna_LineStyle_use_nodes_update");
1629 }
1630
1631 void RNA_def_linestyle(BlenderRNA *brna)
1632 {
1633         rna_def_linestyle_modifiers(brna);
1634         rna_def_linestyle(brna);
1635         rna_def_linestyle_mtex(brna);
1636 }
1637
1638 #endif