4d159adbb574ed4ec2223819147943670de98a3e
[blender.git] / source / blender / blenkernel / intern / linestyle.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2010 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include "MEM_guardedalloc.h"
29
30 #include "DNA_object_types.h"
31 #include "DNA_material_types.h" /* for ramp blend */
32 #include "DNA_texture_types.h"
33
34 #include "BLI_blenlib.h"
35 #include "BLI_math.h"
36 #include "BLI_string_utils.h"
37 #include "BLI_utildefines.h"
38
39 #include "BKE_colorband.h"
40 #include "BKE_context.h"
41 #include "BKE_freestyle.h"
42 #include "BKE_library.h"
43 #include "BKE_linestyle.h"
44 #include "BKE_node.h"
45 #include "BKE_colortools.h"
46 #include "BKE_animsys.h"
47
48 static const char *modifier_name[LS_MODIFIER_NUM] = {
49     NULL,
50     "Along Stroke",
51     "Distance from Camera",
52     "Distance from Object",
53     "Material",
54     "Sampling",
55     "Bezier Curve",
56     "Sinus Displacement",
57     "Spatial Noise",
58     "Perlin Noise 1D",
59     "Perlin Noise 2D",
60     "Backbone Stretcher",
61     "Tip Remover",
62     "Calligraphy",
63     "Polygonalization",
64     "Guiding Lines",
65     "Blueprint",
66     "2D Offset",
67     "2D Transform",
68     "Tangent",
69     "Noise",
70     "Crease Angle",
71     "Simplification",
72     "3D Curvature",
73 };
74
75 void BKE_linestyle_init(FreestyleLineStyle *linestyle)
76 {
77   BLI_assert(MEMCMP_STRUCT_AFTER_IS_ZERO(linestyle, id));
78
79   linestyle->panel = LS_PANEL_STROKES;
80   linestyle->r = linestyle->g = linestyle->b = 0.0f;
81   linestyle->alpha = 1.0f;
82   linestyle->thickness = 3.0f;
83   linestyle->thickness_position = LS_THICKNESS_CENTER;
84   linestyle->thickness_ratio = 0.5f;
85   linestyle->flag = LS_SAME_OBJECT | LS_NO_SORTING | LS_TEXTURE;
86   linestyle->chaining = LS_CHAINING_PLAIN;
87   linestyle->rounds = 3;
88   linestyle->min_angle = DEG2RADF(0.0f);
89   linestyle->max_angle = DEG2RADF(0.0f);
90   linestyle->min_length = 0.0f;
91   linestyle->max_length = 10000.0f;
92   linestyle->split_length = 100;
93   linestyle->chain_count = 10;
94   linestyle->sort_key = LS_SORT_KEY_DISTANCE_FROM_CAMERA;
95   linestyle->integration_type = LS_INTEGRATION_MEAN;
96   linestyle->texstep = 1.0f;
97   linestyle->pr_texture = TEX_PR_TEXTURE;
98
99   BLI_listbase_clear(&linestyle->color_modifiers);
100   BLI_listbase_clear(&linestyle->alpha_modifiers);
101   BLI_listbase_clear(&linestyle->thickness_modifiers);
102   BLI_listbase_clear(&linestyle->geometry_modifiers);
103
104   BKE_linestyle_geometry_modifier_add(linestyle, NULL, LS_MODIFIER_SAMPLING);
105
106   linestyle->caps = LS_CAPS_BUTT;
107 }
108
109 FreestyleLineStyle *BKE_linestyle_new(struct Main *bmain, const char *name)
110 {
111   FreestyleLineStyle *linestyle;
112
113   linestyle = (FreestyleLineStyle *)BKE_libblock_alloc(bmain, ID_LS, name, 0);
114
115   BKE_linestyle_init(linestyle);
116
117   return linestyle;
118 }
119
120 /** Free (or release) any data used by this linestyle (does not free the linestyle itself). */
121 void BKE_linestyle_free(FreestyleLineStyle *linestyle)
122 {
123   LineStyleModifier *m;
124   int a;
125
126   BKE_animdata_free(&linestyle->id, false);
127
128   for (a = 0; a < MAX_MTEX; a++) {
129     MEM_SAFE_FREE(linestyle->mtex[a]);
130   }
131
132   /* is no lib link block, but linestyle extension */
133   if (linestyle->nodetree) {
134     ntreeFreeNestedTree(linestyle->nodetree);
135     MEM_freeN(linestyle->nodetree);
136     linestyle->nodetree = NULL;
137   }
138
139   while ((m = (LineStyleModifier *)linestyle->color_modifiers.first)) {
140     BKE_linestyle_color_modifier_remove(linestyle, m);
141   }
142   while ((m = (LineStyleModifier *)linestyle->alpha_modifiers.first)) {
143     BKE_linestyle_alpha_modifier_remove(linestyle, m);
144   }
145   while ((m = (LineStyleModifier *)linestyle->thickness_modifiers.first)) {
146     BKE_linestyle_thickness_modifier_remove(linestyle, m);
147   }
148   while ((m = (LineStyleModifier *)linestyle->geometry_modifiers.first)) {
149     BKE_linestyle_geometry_modifier_remove(linestyle, m);
150   }
151 }
152
153 /**
154  * Only copy internal data of Linestyle ID from source to already allocated/initialized destination.
155  * You probably never want to use that directly, use BKE_id_copy or BKE_id_copy_ex for typical needs.
156  *
157  * WARNING! This function will not handle ID user count!
158  *
159  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
160  */
161 void BKE_linestyle_copy_data(struct Main *bmain,
162                              FreestyleLineStyle *linestyle_dst,
163                              const FreestyleLineStyle *linestyle_src,
164                              const int flag)
165 {
166   /* We never handle usercount here for own data. */
167   const int flag_subdata = flag | LIB_ID_CREATE_NO_USER_REFCOUNT;
168
169   for (int a = 0; a < MAX_MTEX; a++) {
170     if (linestyle_src->mtex[a]) {
171       linestyle_dst->mtex[a] = MEM_mallocN(sizeof(*linestyle_dst->mtex[a]), __func__);
172       *linestyle_dst->mtex[a] = *linestyle_src->mtex[a];
173     }
174   }
175
176   if (linestyle_src->nodetree) {
177     /* Note: nodetree is *not* in bmain, however this specific case is handled at lower level
178      *       (see BKE_libblock_copy_ex()). */
179     BKE_id_copy_ex(bmain, (ID *)linestyle_src->nodetree, (ID **)&linestyle_dst->nodetree, flag);
180   }
181
182   LineStyleModifier *m;
183   BLI_listbase_clear(&linestyle_dst->color_modifiers);
184   for (m = (LineStyleModifier *)linestyle_src->color_modifiers.first; m; m = m->next) {
185     BKE_linestyle_color_modifier_copy(linestyle_dst, m, flag_subdata);
186   }
187   BLI_listbase_clear(&linestyle_dst->alpha_modifiers);
188   for (m = (LineStyleModifier *)linestyle_src->alpha_modifiers.first; m; m = m->next) {
189     BKE_linestyle_alpha_modifier_copy(linestyle_dst, m, flag_subdata);
190   }
191   BLI_listbase_clear(&linestyle_dst->thickness_modifiers);
192   for (m = (LineStyleModifier *)linestyle_src->thickness_modifiers.first; m; m = m->next) {
193     BKE_linestyle_thickness_modifier_copy(linestyle_dst, m, flag_subdata);
194   }
195   BLI_listbase_clear(&linestyle_dst->geometry_modifiers);
196   for (m = (LineStyleModifier *)linestyle_src->geometry_modifiers.first; m; m = m->next) {
197     BKE_linestyle_geometry_modifier_copy(linestyle_dst, m, flag_subdata);
198   }
199 }
200
201 FreestyleLineStyle *BKE_linestyle_copy(struct Main *bmain, const FreestyleLineStyle *linestyle)
202 {
203   FreestyleLineStyle *linestyle_copy;
204   BKE_id_copy(bmain, &linestyle->id, (ID **)&linestyle_copy);
205   return linestyle_copy;
206 }
207
208 void BKE_linestyle_make_local(struct Main *bmain,
209                               FreestyleLineStyle *linestyle,
210                               const bool lib_local)
211 {
212   BKE_id_make_local_generic(bmain, &linestyle->id, true, lib_local);
213 }
214
215 FreestyleLineStyle *BKE_linestyle_active_from_view_layer(ViewLayer *view_layer)
216 {
217   FreestyleConfig *config = &view_layer->freestyle_config;
218   FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(config);
219   return (lineset) ? lineset->linestyle : NULL;
220 }
221
222 static LineStyleModifier *new_modifier(const char *name, int type, size_t size)
223 {
224   LineStyleModifier *m;
225
226   if (!name) {
227     name = modifier_name[type];
228   }
229   m = (LineStyleModifier *)MEM_callocN(size, "line style modifier");
230   m->type = type;
231   BLI_strncpy(m->name, name, sizeof(m->name));
232   m->influence = 1.0f;
233   m->flags = LS_MODIFIER_ENABLED | LS_MODIFIER_EXPANDED;
234
235   return m;
236 }
237
238 static void add_to_modifier_list(ListBase *lb, LineStyleModifier *m)
239 {
240   BLI_addtail(lb, (void *)m);
241   BLI_uniquename(
242       lb, m, modifier_name[m->type], '.', offsetof(LineStyleModifier, name), sizeof(m->name));
243 }
244
245 static LineStyleModifier *alloc_color_modifier(const char *name, int type)
246 {
247   size_t size;
248
249   switch (type) {
250     case LS_MODIFIER_ALONG_STROKE:
251       size = sizeof(LineStyleColorModifier_AlongStroke);
252       break;
253     case LS_MODIFIER_DISTANCE_FROM_CAMERA:
254       size = sizeof(LineStyleColorModifier_DistanceFromCamera);
255       break;
256     case LS_MODIFIER_DISTANCE_FROM_OBJECT:
257       size = sizeof(LineStyleColorModifier_DistanceFromObject);
258       break;
259     case LS_MODIFIER_MATERIAL:
260       size = sizeof(LineStyleColorModifier_Material);
261       break;
262     case LS_MODIFIER_TANGENT:
263       size = sizeof(LineStyleColorModifier_Tangent);
264       break;
265     case LS_MODIFIER_NOISE:
266       size = sizeof(LineStyleColorModifier_Noise);
267       break;
268     case LS_MODIFIER_CREASE_ANGLE:
269       size = sizeof(LineStyleColorModifier_CreaseAngle);
270       break;
271     case LS_MODIFIER_CURVATURE_3D:
272       size = sizeof(LineStyleColorModifier_Curvature_3D);
273       break;
274     default:
275       return NULL; /* unknown modifier type */
276   }
277
278   return new_modifier(name, type, size);
279 }
280
281 LineStyleModifier *BKE_linestyle_color_modifier_add(FreestyleLineStyle *linestyle,
282                                                     const char *name,
283                                                     int type)
284 {
285   LineStyleModifier *m;
286
287   m = alloc_color_modifier(name, type);
288   if (UNLIKELY(m == NULL)) {
289     return NULL;
290   }
291   m->blend = MA_RAMP_BLEND;
292
293   switch (type) {
294     case LS_MODIFIER_ALONG_STROKE:
295       ((LineStyleColorModifier_AlongStroke *)m)->color_ramp = BKE_colorband_add(true);
296       break;
297     case LS_MODIFIER_DISTANCE_FROM_CAMERA:
298       ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp = BKE_colorband_add(true);
299       ((LineStyleColorModifier_DistanceFromCamera *)m)->range_min = 0.0f;
300       ((LineStyleColorModifier_DistanceFromCamera *)m)->range_max = 10000.0f;
301       break;
302     case LS_MODIFIER_DISTANCE_FROM_OBJECT:
303       ((LineStyleColorModifier_DistanceFromObject *)m)->target = NULL;
304       ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp = BKE_colorband_add(true);
305       ((LineStyleColorModifier_DistanceFromObject *)m)->range_min = 0.0f;
306       ((LineStyleColorModifier_DistanceFromObject *)m)->range_max = 10000.0f;
307       break;
308     case LS_MODIFIER_MATERIAL:
309       ((LineStyleColorModifier_Material *)m)->color_ramp = BKE_colorband_add(true);
310       ((LineStyleColorModifier_Material *)m)->mat_attr = LS_MODIFIER_MATERIAL_LINE;
311       break;
312     case LS_MODIFIER_TANGENT:
313       ((LineStyleColorModifier_Tangent *)m)->color_ramp = BKE_colorband_add(true);
314       break;
315     case LS_MODIFIER_NOISE:
316       ((LineStyleColorModifier_Noise *)m)->color_ramp = BKE_colorband_add(true);
317       ((LineStyleColorModifier_Noise *)m)->amplitude = 10.0f;
318       ((LineStyleColorModifier_Noise *)m)->period = 10.0f;
319       ((LineStyleColorModifier_Noise *)m)->seed = 512;
320       break;
321     case LS_MODIFIER_CREASE_ANGLE:
322       ((LineStyleColorModifier_CreaseAngle *)m)->color_ramp = BKE_colorband_add(true);
323       ((LineStyleColorModifier_CreaseAngle *)m)->min_angle = 0.0f;
324       ((LineStyleColorModifier_CreaseAngle *)m)->max_angle = DEG2RADF(180.0f);
325       break;
326     case LS_MODIFIER_CURVATURE_3D:
327       ((LineStyleColorModifier_Curvature_3D *)m)->color_ramp = BKE_colorband_add(true);
328       ((LineStyleColorModifier_Curvature_3D *)m)->min_curvature = 0.0f;
329       ((LineStyleColorModifier_Curvature_3D *)m)->max_curvature = 0.5f;
330       break;
331     default:
332       return NULL; /* unknown modifier type */
333   }
334   add_to_modifier_list(&linestyle->color_modifiers, m);
335
336   return m;
337 }
338
339 LineStyleModifier *BKE_linestyle_color_modifier_copy(FreestyleLineStyle *linestyle,
340                                                      const LineStyleModifier *m,
341                                                      const int flag)
342 {
343   LineStyleModifier *new_m;
344
345   new_m = alloc_color_modifier(m->name, m->type);
346   if (UNLIKELY(new_m == NULL)) {
347     return NULL;
348   }
349   new_m->influence = m->influence;
350   new_m->flags = m->flags;
351   new_m->blend = m->blend;
352
353   switch (m->type) {
354     case LS_MODIFIER_ALONG_STROKE: {
355       LineStyleColorModifier_AlongStroke *p = (LineStyleColorModifier_AlongStroke *)m;
356       LineStyleColorModifier_AlongStroke *q = (LineStyleColorModifier_AlongStroke *)new_m;
357       q->color_ramp = MEM_dupallocN(p->color_ramp);
358       break;
359     }
360     case LS_MODIFIER_DISTANCE_FROM_CAMERA: {
361       LineStyleColorModifier_DistanceFromCamera *p = (LineStyleColorModifier_DistanceFromCamera *)
362           m;
363       LineStyleColorModifier_DistanceFromCamera *q = (LineStyleColorModifier_DistanceFromCamera *)
364           new_m;
365       q->color_ramp = MEM_dupallocN(p->color_ramp);
366       q->range_min = p->range_min;
367       q->range_max = p->range_max;
368       break;
369     }
370     case LS_MODIFIER_DISTANCE_FROM_OBJECT: {
371       LineStyleColorModifier_DistanceFromObject *p = (LineStyleColorModifier_DistanceFromObject *)
372           m;
373       LineStyleColorModifier_DistanceFromObject *q = (LineStyleColorModifier_DistanceFromObject *)
374           new_m;
375       q->target = p->target;
376       if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
377         id_us_plus((ID *)q->target);
378       }
379       q->color_ramp = MEM_dupallocN(p->color_ramp);
380       q->range_min = p->range_min;
381       q->range_max = p->range_max;
382       break;
383     }
384     case LS_MODIFIER_MATERIAL: {
385       LineStyleColorModifier_Material *p = (LineStyleColorModifier_Material *)m;
386       LineStyleColorModifier_Material *q = (LineStyleColorModifier_Material *)new_m;
387       q->color_ramp = MEM_dupallocN(p->color_ramp);
388       q->flags = p->flags;
389       q->mat_attr = p->mat_attr;
390       break;
391     }
392     case LS_MODIFIER_TANGENT: {
393       LineStyleColorModifier_Tangent *p = (LineStyleColorModifier_Tangent *)m;
394       LineStyleColorModifier_Tangent *q = (LineStyleColorModifier_Tangent *)new_m;
395       q->color_ramp = MEM_dupallocN(p->color_ramp);
396       break;
397     }
398     case LS_MODIFIER_NOISE: {
399       LineStyleColorModifier_Noise *p = (LineStyleColorModifier_Noise *)m;
400       LineStyleColorModifier_Noise *q = (LineStyleColorModifier_Noise *)new_m;
401       q->color_ramp = MEM_dupallocN(p->color_ramp);
402       q->amplitude = p->amplitude;
403       q->period = p->period;
404       q->seed = p->seed;
405       break;
406     }
407     case LS_MODIFIER_CREASE_ANGLE: {
408       LineStyleColorModifier_CreaseAngle *p = (LineStyleColorModifier_CreaseAngle *)m;
409       LineStyleColorModifier_CreaseAngle *q = (LineStyleColorModifier_CreaseAngle *)new_m;
410       q->color_ramp = MEM_dupallocN(p->color_ramp);
411       q->min_angle = p->min_angle;
412       q->max_angle = p->max_angle;
413       break;
414     }
415     case LS_MODIFIER_CURVATURE_3D: {
416       LineStyleColorModifier_Curvature_3D *p = (LineStyleColorModifier_Curvature_3D *)m;
417       LineStyleColorModifier_Curvature_3D *q = (LineStyleColorModifier_Curvature_3D *)new_m;
418       q->color_ramp = MEM_dupallocN(p->color_ramp);
419       q->min_curvature = p->min_curvature;
420       q->max_curvature = p->max_curvature;
421       break;
422     }
423     default:
424       return NULL; /* unknown modifier type */
425   }
426   add_to_modifier_list(&linestyle->color_modifiers, new_m);
427
428   return new_m;
429 }
430
431 int BKE_linestyle_color_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *m)
432 {
433   if (BLI_findindex(&linestyle->color_modifiers, m) == -1) {
434     return -1;
435   }
436   switch (m->type) {
437     case LS_MODIFIER_ALONG_STROKE:
438       MEM_freeN(((LineStyleColorModifier_AlongStroke *)m)->color_ramp);
439       break;
440     case LS_MODIFIER_DISTANCE_FROM_CAMERA:
441       MEM_freeN(((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp);
442       break;
443     case LS_MODIFIER_DISTANCE_FROM_OBJECT:
444       MEM_freeN(((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp);
445       break;
446     case LS_MODIFIER_MATERIAL:
447       MEM_freeN(((LineStyleColorModifier_Material *)m)->color_ramp);
448       break;
449     case LS_MODIFIER_TANGENT:
450       MEM_freeN(((LineStyleColorModifier_Tangent *)m)->color_ramp);
451       break;
452     case LS_MODIFIER_NOISE:
453       MEM_freeN(((LineStyleColorModifier_Noise *)m)->color_ramp);
454       break;
455     case LS_MODIFIER_CREASE_ANGLE:
456       MEM_freeN(((LineStyleColorModifier_CreaseAngle *)m)->color_ramp);
457       break;
458     case LS_MODIFIER_CURVATURE_3D:
459       MEM_freeN(((LineStyleColorModifier_Curvature_3D *)m)->color_ramp);
460       break;
461   }
462   BLI_freelinkN(&linestyle->color_modifiers, m);
463   return 0;
464 }
465
466 static LineStyleModifier *alloc_alpha_modifier(const char *name, int type)
467 {
468   size_t size;
469
470   switch (type) {
471     case LS_MODIFIER_ALONG_STROKE:
472       size = sizeof(LineStyleAlphaModifier_AlongStroke);
473       break;
474     case LS_MODIFIER_DISTANCE_FROM_CAMERA:
475       size = sizeof(LineStyleAlphaModifier_DistanceFromCamera);
476       break;
477     case LS_MODIFIER_DISTANCE_FROM_OBJECT:
478       size = sizeof(LineStyleAlphaModifier_DistanceFromObject);
479       break;
480     case LS_MODIFIER_MATERIAL:
481       size = sizeof(LineStyleAlphaModifier_Material);
482       break;
483     case LS_MODIFIER_TANGENT:
484       size = sizeof(LineStyleAlphaModifier_Tangent);
485       break;
486     case LS_MODIFIER_NOISE:
487       size = sizeof(LineStyleAlphaModifier_Noise);
488       break;
489     case LS_MODIFIER_CREASE_ANGLE:
490       size = sizeof(LineStyleAlphaModifier_CreaseAngle);
491       break;
492     case LS_MODIFIER_CURVATURE_3D:
493       size = sizeof(LineStyleAlphaModifier_Curvature_3D);
494       break;
495     default:
496       return NULL; /* unknown modifier type */
497   }
498   return new_modifier(name, type, size);
499 }
500
501 LineStyleModifier *BKE_linestyle_alpha_modifier_add(FreestyleLineStyle *linestyle,
502                                                     const char *name,
503                                                     int type)
504 {
505   LineStyleModifier *m;
506
507   m = alloc_alpha_modifier(name, type);
508   m->blend = LS_VALUE_BLEND;
509
510   switch (type) {
511     case LS_MODIFIER_ALONG_STROKE: {
512       LineStyleAlphaModifier_AlongStroke *p = (LineStyleAlphaModifier_AlongStroke *)m;
513       p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
514       break;
515     }
516     case LS_MODIFIER_DISTANCE_FROM_CAMERA: {
517       LineStyleAlphaModifier_DistanceFromCamera *p = (LineStyleAlphaModifier_DistanceFromCamera *)
518           m;
519       p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
520       p->range_min = 0.0f;
521       p->range_max = 10000.0f;
522       break;
523     }
524     case LS_MODIFIER_DISTANCE_FROM_OBJECT: {
525       LineStyleAlphaModifier_DistanceFromObject *p = (LineStyleAlphaModifier_DistanceFromObject *)
526           m;
527       p->target = NULL;
528       p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
529       p->range_min = 0.0f;
530       p->range_max = 10000.0f;
531       break;
532     }
533     case LS_MODIFIER_MATERIAL: {
534       LineStyleAlphaModifier_Material *p = (LineStyleAlphaModifier_Material *)m;
535       p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
536       p->mat_attr = LS_MODIFIER_MATERIAL_LINE_A;
537       break;
538     }
539     case LS_MODIFIER_TANGENT: {
540       LineStyleAlphaModifier_Tangent *p = (LineStyleAlphaModifier_Tangent *)m;
541       p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
542       break;
543     }
544     case LS_MODIFIER_NOISE: {
545       LineStyleAlphaModifier_Noise *p = (LineStyleAlphaModifier_Noise *)m;
546       p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
547       ((LineStyleAlphaModifier_Noise *)m)->amplitude = 10.0f;
548       ((LineStyleAlphaModifier_Noise *)m)->period = 10.0f;
549       ((LineStyleAlphaModifier_Noise *)m)->seed = 512;
550       break;
551     }
552     case LS_MODIFIER_CREASE_ANGLE: {
553       LineStyleAlphaModifier_CreaseAngle *p = (LineStyleAlphaModifier_CreaseAngle *)m;
554       p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
555       ((LineStyleAlphaModifier_CreaseAngle *)m)->min_angle = 0.0f;
556       ((LineStyleAlphaModifier_CreaseAngle *)m)->max_angle = DEG2RADF(180.0f);
557       break;
558     }
559     case LS_MODIFIER_CURVATURE_3D: {
560       LineStyleAlphaModifier_Curvature_3D *p = (LineStyleAlphaModifier_Curvature_3D *)m;
561       p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
562       ((LineStyleAlphaModifier_Curvature_3D *)m)->min_curvature = 0.0f;
563       ((LineStyleAlphaModifier_Curvature_3D *)m)->max_curvature = 0.5f;
564       break;
565     }
566     default:
567       return NULL; /* unknown modifier type */
568   }
569   add_to_modifier_list(&linestyle->alpha_modifiers, m);
570
571   return m;
572 }
573
574 LineStyleModifier *BKE_linestyle_alpha_modifier_copy(FreestyleLineStyle *linestyle,
575                                                      const LineStyleModifier *m,
576                                                      const int UNUSED(flag))
577 {
578   LineStyleModifier *new_m;
579
580   new_m = alloc_alpha_modifier(m->name, m->type);
581   new_m->influence = m->influence;
582   new_m->flags = m->flags;
583   new_m->blend = m->blend;
584
585   switch (m->type) {
586     case LS_MODIFIER_ALONG_STROKE: {
587       LineStyleAlphaModifier_AlongStroke *p = (LineStyleAlphaModifier_AlongStroke *)m;
588       LineStyleAlphaModifier_AlongStroke *q = (LineStyleAlphaModifier_AlongStroke *)new_m;
589       q->curve = curvemapping_copy(p->curve);
590       q->flags = p->flags;
591       break;
592     }
593     case LS_MODIFIER_DISTANCE_FROM_CAMERA: {
594       LineStyleAlphaModifier_DistanceFromCamera *p = (LineStyleAlphaModifier_DistanceFromCamera *)
595           m;
596       LineStyleAlphaModifier_DistanceFromCamera *q = (LineStyleAlphaModifier_DistanceFromCamera *)
597           new_m;
598       q->curve = curvemapping_copy(p->curve);
599       q->flags = p->flags;
600       q->range_min = p->range_min;
601       q->range_max = p->range_max;
602       break;
603     }
604     case LS_MODIFIER_DISTANCE_FROM_OBJECT: {
605       LineStyleAlphaModifier_DistanceFromObject *p = (LineStyleAlphaModifier_DistanceFromObject *)
606           m;
607       LineStyleAlphaModifier_DistanceFromObject *q = (LineStyleAlphaModifier_DistanceFromObject *)
608           new_m;
609       if (p->target) {
610         id_us_plus(&p->target->id);
611       }
612       q->target = p->target;
613       q->curve = curvemapping_copy(p->curve);
614       q->flags = p->flags;
615       q->range_min = p->range_min;
616       q->range_max = p->range_max;
617       break;
618     }
619     case LS_MODIFIER_MATERIAL: {
620       LineStyleAlphaModifier_Material *p = (LineStyleAlphaModifier_Material *)m;
621       LineStyleAlphaModifier_Material *q = (LineStyleAlphaModifier_Material *)new_m;
622       q->curve = curvemapping_copy(p->curve);
623       q->flags = p->flags;
624       q->mat_attr = p->mat_attr;
625       break;
626     }
627     case LS_MODIFIER_TANGENT: {
628       LineStyleAlphaModifier_Tangent *p = (LineStyleAlphaModifier_Tangent *)m;
629       LineStyleAlphaModifier_Tangent *q = (LineStyleAlphaModifier_Tangent *)new_m;
630       q->curve = curvemapping_copy(p->curve);
631       q->flags = p->flags;
632       break;
633     }
634     case LS_MODIFIER_NOISE: {
635       LineStyleAlphaModifier_Noise *p = (LineStyleAlphaModifier_Noise *)m;
636       LineStyleAlphaModifier_Noise *q = (LineStyleAlphaModifier_Noise *)new_m;
637       q->curve = curvemapping_copy(p->curve);
638       q->flags = p->flags;
639       q->amplitude = p->amplitude;
640       q->period = p->period;
641       q->seed = p->seed;
642       break;
643     }
644     case LS_MODIFIER_CREASE_ANGLE: {
645       LineStyleAlphaModifier_CreaseAngle *p = (LineStyleAlphaModifier_CreaseAngle *)m;
646       LineStyleAlphaModifier_CreaseAngle *q = (LineStyleAlphaModifier_CreaseAngle *)new_m;
647       q->curve = curvemapping_copy(p->curve);
648       q->flags = p->flags;
649       q->min_angle = p->min_angle;
650       q->max_angle = p->max_angle;
651       break;
652     }
653     case LS_MODIFIER_CURVATURE_3D: {
654       LineStyleAlphaModifier_Curvature_3D *p = (LineStyleAlphaModifier_Curvature_3D *)m;
655       LineStyleAlphaModifier_Curvature_3D *q = (LineStyleAlphaModifier_Curvature_3D *)new_m;
656       q->curve = curvemapping_copy(p->curve);
657       q->flags = p->flags;
658       q->min_curvature = p->min_curvature;
659       q->max_curvature = p->max_curvature;
660       break;
661     }
662     default:
663       return NULL; /* unknown modifier type */
664   }
665   add_to_modifier_list(&linestyle->alpha_modifiers, new_m);
666
667   return new_m;
668 }
669
670 int BKE_linestyle_alpha_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *m)
671 {
672   if (BLI_findindex(&linestyle->alpha_modifiers, m) == -1) {
673     return -1;
674   }
675   switch (m->type) {
676     case LS_MODIFIER_ALONG_STROKE:
677       curvemapping_free(((LineStyleAlphaModifier_AlongStroke *)m)->curve);
678       break;
679     case LS_MODIFIER_DISTANCE_FROM_CAMERA:
680       curvemapping_free(((LineStyleAlphaModifier_DistanceFromCamera *)m)->curve);
681       break;
682     case LS_MODIFIER_DISTANCE_FROM_OBJECT:
683       curvemapping_free(((LineStyleAlphaModifier_DistanceFromObject *)m)->curve);
684       break;
685     case LS_MODIFIER_MATERIAL:
686       curvemapping_free(((LineStyleAlphaModifier_Material *)m)->curve);
687       break;
688     case LS_MODIFIER_TANGENT:
689       curvemapping_free(((LineStyleAlphaModifier_Tangent *)m)->curve);
690       break;
691     case LS_MODIFIER_NOISE:
692       curvemapping_free(((LineStyleAlphaModifier_Noise *)m)->curve);
693       break;
694     case LS_MODIFIER_CREASE_ANGLE:
695       curvemapping_free(((LineStyleAlphaModifier_CreaseAngle *)m)->curve);
696       break;
697     case LS_MODIFIER_CURVATURE_3D:
698       curvemapping_free(((LineStyleAlphaModifier_Curvature_3D *)m)->curve);
699       break;
700   }
701   BLI_freelinkN(&linestyle->alpha_modifiers, m);
702   return 0;
703 }
704
705 static LineStyleModifier *alloc_thickness_modifier(const char *name, int type)
706 {
707   size_t size;
708
709   switch (type) {
710     case LS_MODIFIER_ALONG_STROKE:
711       size = sizeof(LineStyleThicknessModifier_AlongStroke);
712       break;
713     case LS_MODIFIER_DISTANCE_FROM_CAMERA:
714       size = sizeof(LineStyleThicknessModifier_DistanceFromCamera);
715       break;
716     case LS_MODIFIER_DISTANCE_FROM_OBJECT:
717       size = sizeof(LineStyleThicknessModifier_DistanceFromObject);
718       break;
719     case LS_MODIFIER_MATERIAL:
720       size = sizeof(LineStyleThicknessModifier_Material);
721       break;
722     case LS_MODIFIER_CALLIGRAPHY:
723       size = sizeof(LineStyleThicknessModifier_Calligraphy);
724       break;
725     case LS_MODIFIER_TANGENT:
726       size = sizeof(LineStyleThicknessModifier_Tangent);
727       break;
728     case LS_MODIFIER_NOISE:
729       size = sizeof(LineStyleThicknessModifier_Noise);
730       break;
731     case LS_MODIFIER_CREASE_ANGLE:
732       size = sizeof(LineStyleThicknessModifier_CreaseAngle);
733       break;
734     case LS_MODIFIER_CURVATURE_3D:
735       size = sizeof(LineStyleThicknessModifier_Curvature_3D);
736       break;
737     default:
738       return NULL; /* unknown modifier type */
739   }
740
741   return new_modifier(name, type, size);
742 }
743
744 LineStyleModifier *BKE_linestyle_thickness_modifier_add(FreestyleLineStyle *linestyle,
745                                                         const char *name,
746                                                         int type)
747 {
748   LineStyleModifier *m;
749
750   m = alloc_thickness_modifier(name, type);
751   m->blend = LS_VALUE_BLEND;
752
753   switch (type) {
754     case LS_MODIFIER_ALONG_STROKE: {
755       LineStyleThicknessModifier_AlongStroke *p = (LineStyleThicknessModifier_AlongStroke *)m;
756       p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
757       p->value_min = 0.0f;
758       p->value_max = 1.0f;
759       break;
760     }
761     case LS_MODIFIER_DISTANCE_FROM_CAMERA: {
762       LineStyleThicknessModifier_DistanceFromCamera *p =
763           (LineStyleThicknessModifier_DistanceFromCamera *)m;
764       p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
765       p->range_min = 0.0f;
766       p->range_max = 1000.0f;
767       p->value_min = 0.0f;
768       p->value_max = 1.0f;
769       break;
770     }
771     case LS_MODIFIER_DISTANCE_FROM_OBJECT: {
772       LineStyleThicknessModifier_DistanceFromObject *p =
773           (LineStyleThicknessModifier_DistanceFromObject *)m;
774       p->target = NULL;
775       p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
776       p->range_min = 0.0f;
777       p->range_max = 1000.0f;
778       p->value_min = 0.0f;
779       p->value_max = 1.0f;
780       break;
781     }
782     case LS_MODIFIER_MATERIAL: {
783       LineStyleThicknessModifier_Material *p = (LineStyleThicknessModifier_Material *)m;
784       p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
785       p->mat_attr = LS_MODIFIER_MATERIAL_LINE;
786       p->value_min = 0.0f;
787       p->value_max = 1.0f;
788       break;
789     }
790     case LS_MODIFIER_CALLIGRAPHY: {
791       LineStyleThicknessModifier_Calligraphy *p = (LineStyleThicknessModifier_Calligraphy *)m;
792       p->min_thickness = 1.0f;
793       p->max_thickness = 10.0f;
794       p->orientation = DEG2RADF(60.0f);
795       break;
796     }
797     case LS_MODIFIER_TANGENT: {
798       LineStyleThicknessModifier_Tangent *p = (LineStyleThicknessModifier_Tangent *)m;
799       p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
800       p->min_thickness = 1.0f;
801       p->max_thickness = 10.0f;
802       break;
803     }
804     case LS_MODIFIER_NOISE: {
805       LineStyleThicknessModifier_Noise *p = (LineStyleThicknessModifier_Noise *)m;
806       p->period = 10.0f;
807       p->amplitude = 10.0f;
808       p->seed = 512;
809       p->flags = LS_THICKNESS_ASYMMETRIC;
810       break;
811     }
812     case LS_MODIFIER_CREASE_ANGLE: {
813       LineStyleThicknessModifier_CreaseAngle *p = (LineStyleThicknessModifier_CreaseAngle *)m;
814       p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
815       p->min_angle = 0.0f;
816       p->max_angle = DEG2RADF(180.0f);
817       p->min_thickness = 1.0f;
818       p->max_thickness = 10.0f;
819       break;
820     }
821     case LS_MODIFIER_CURVATURE_3D: {
822       LineStyleThicknessModifier_Curvature_3D *p = (LineStyleThicknessModifier_Curvature_3D *)m;
823       p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
824       p->min_curvature = 0.0f;
825       p->max_curvature = 0.5f;
826       p->min_thickness = 1.0f;
827       p->max_thickness = 10.0f;
828       break;
829     }
830     default:
831       return NULL; /* unknown modifier type */
832   }
833   add_to_modifier_list(&linestyle->thickness_modifiers, m);
834
835   return m;
836 }
837
838 LineStyleModifier *BKE_linestyle_thickness_modifier_copy(FreestyleLineStyle *linestyle,
839                                                          const LineStyleModifier *m,
840                                                          const int flag)
841 {
842   LineStyleModifier *new_m;
843
844   new_m = alloc_thickness_modifier(m->name, m->type);
845   if (!new_m) {
846     return NULL;
847   }
848   new_m->influence = m->influence;
849   new_m->flags = m->flags;
850   new_m->blend = m->blend;
851
852   switch (m->type) {
853     case LS_MODIFIER_ALONG_STROKE: {
854       LineStyleThicknessModifier_AlongStroke *p = (LineStyleThicknessModifier_AlongStroke *)m;
855       LineStyleThicknessModifier_AlongStroke *q = (LineStyleThicknessModifier_AlongStroke *)new_m;
856       q->curve = curvemapping_copy(p->curve);
857       q->flags = p->flags;
858       q->value_min = p->value_min;
859       q->value_max = p->value_max;
860       break;
861     }
862     case LS_MODIFIER_DISTANCE_FROM_CAMERA: {
863       LineStyleThicknessModifier_DistanceFromCamera *p =
864           (LineStyleThicknessModifier_DistanceFromCamera *)m;
865       LineStyleThicknessModifier_DistanceFromCamera *q =
866           (LineStyleThicknessModifier_DistanceFromCamera *)new_m;
867       q->curve = curvemapping_copy(p->curve);
868       q->flags = p->flags;
869       q->range_min = p->range_min;
870       q->range_max = p->range_max;
871       q->value_min = p->value_min;
872       q->value_max = p->value_max;
873       break;
874     }
875     case LS_MODIFIER_DISTANCE_FROM_OBJECT: {
876       LineStyleThicknessModifier_DistanceFromObject *p =
877           (LineStyleThicknessModifier_DistanceFromObject *)m;
878       LineStyleThicknessModifier_DistanceFromObject *q =
879           (LineStyleThicknessModifier_DistanceFromObject *)new_m;
880       q->target = p->target;
881       if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
882         id_us_plus((ID *)q->target);
883       }
884       q->curve = curvemapping_copy(p->curve);
885       q->flags = p->flags;
886       q->range_min = p->range_min;
887       q->range_max = p->range_max;
888       q->value_min = p->value_min;
889       q->value_max = p->value_max;
890       break;
891     }
892     case LS_MODIFIER_MATERIAL: {
893       LineStyleThicknessModifier_Material *p = (LineStyleThicknessModifier_Material *)m;
894       LineStyleThicknessModifier_Material *q = (LineStyleThicknessModifier_Material *)new_m;
895       q->curve = curvemapping_copy(p->curve);
896       q->flags = p->flags;
897       q->mat_attr = p->mat_attr;
898       q->value_min = p->value_min;
899       q->value_max = p->value_max;
900       break;
901     }
902     case LS_MODIFIER_CALLIGRAPHY: {
903       LineStyleThicknessModifier_Calligraphy *p = (LineStyleThicknessModifier_Calligraphy *)m;
904       LineStyleThicknessModifier_Calligraphy *q = (LineStyleThicknessModifier_Calligraphy *)new_m;
905       q->min_thickness = p->min_thickness;
906       q->max_thickness = p->max_thickness;
907       q->orientation = p->orientation;
908       break;
909     }
910     case LS_MODIFIER_TANGENT: {
911       LineStyleThicknessModifier_Tangent *p = (LineStyleThicknessModifier_Tangent *)m;
912       LineStyleThicknessModifier_Tangent *q = (LineStyleThicknessModifier_Tangent *)new_m;
913       q->curve = curvemapping_copy(p->curve);
914       q->flags = p->flags;
915       q->min_thickness = p->min_thickness;
916       q->max_thickness = p->max_thickness;
917       break;
918     }
919     case LS_MODIFIER_NOISE: {
920       LineStyleThicknessModifier_Noise *p = (LineStyleThicknessModifier_Noise *)m;
921       LineStyleThicknessModifier_Noise *q = (LineStyleThicknessModifier_Noise *)new_m;
922       q->amplitude = p->amplitude;
923       q->period = p->period;
924       q->seed = p->seed;
925       q->flags = p->flags;
926       break;
927     }
928     case LS_MODIFIER_CURVATURE_3D: {
929       LineStyleThicknessModifier_Curvature_3D *p = (LineStyleThicknessModifier_Curvature_3D *)m;
930       LineStyleThicknessModifier_Curvature_3D *q = (LineStyleThicknessModifier_Curvature_3D *)
931           new_m;
932       q->curve = curvemapping_copy(p->curve);
933       q->flags = p->flags;
934       q->min_curvature = p->min_curvature;
935       q->max_curvature = p->max_curvature;
936       q->min_thickness = p->min_thickness;
937       q->max_thickness = p->max_thickness;
938       break;
939     }
940     case LS_MODIFIER_CREASE_ANGLE: {
941       LineStyleThicknessModifier_CreaseAngle *p = (LineStyleThicknessModifier_CreaseAngle *)m;
942       LineStyleThicknessModifier_CreaseAngle *q = (LineStyleThicknessModifier_CreaseAngle *)new_m;
943       q->curve = curvemapping_copy(p->curve);
944       q->flags = p->flags;
945       q->min_angle = p->min_angle;
946       q->max_angle = p->max_angle;
947       q->min_thickness = p->min_thickness;
948       q->max_thickness = p->max_thickness;
949       break;
950     }
951     default:
952       return NULL; /* unknown modifier type */
953   }
954   add_to_modifier_list(&linestyle->thickness_modifiers, new_m);
955
956   return new_m;
957 }
958
959 int BKE_linestyle_thickness_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *m)
960 {
961   if (BLI_findindex(&linestyle->thickness_modifiers, m) == -1) {
962     return -1;
963   }
964   switch (m->type) {
965     case LS_MODIFIER_ALONG_STROKE:
966       curvemapping_free(((LineStyleThicknessModifier_AlongStroke *)m)->curve);
967       break;
968     case LS_MODIFIER_DISTANCE_FROM_CAMERA:
969       curvemapping_free(((LineStyleThicknessModifier_DistanceFromCamera *)m)->curve);
970       break;
971     case LS_MODIFIER_DISTANCE_FROM_OBJECT:
972       curvemapping_free(((LineStyleThicknessModifier_DistanceFromObject *)m)->curve);
973       break;
974     case LS_MODIFIER_MATERIAL:
975       curvemapping_free(((LineStyleThicknessModifier_Material *)m)->curve);
976       break;
977     case LS_MODIFIER_CALLIGRAPHY:
978       break;
979     case LS_MODIFIER_TANGENT:
980       curvemapping_free(((LineStyleThicknessModifier_Tangent *)m)->curve);
981       break;
982     case LS_MODIFIER_NOISE:
983       break;
984     case LS_MODIFIER_CREASE_ANGLE:
985       break;
986     case LS_MODIFIER_CURVATURE_3D:
987       break;
988   }
989   BLI_freelinkN(&linestyle->thickness_modifiers, m);
990   return 0;
991 }
992
993 static LineStyleModifier *alloc_geometry_modifier(const char *name, int type)
994 {
995   size_t size;
996
997   switch (type) {
998     case LS_MODIFIER_SAMPLING:
999       size = sizeof(LineStyleGeometryModifier_Sampling);
1000       break;
1001     case LS_MODIFIER_BEZIER_CURVE:
1002       size = sizeof(LineStyleGeometryModifier_BezierCurve);
1003       break;
1004     case LS_MODIFIER_SINUS_DISPLACEMENT:
1005       size = sizeof(LineStyleGeometryModifier_SinusDisplacement);
1006       break;
1007     case LS_MODIFIER_SPATIAL_NOISE:
1008       size = sizeof(LineStyleGeometryModifier_SpatialNoise);
1009       break;
1010     case LS_MODIFIER_PERLIN_NOISE_1D:
1011       size = sizeof(LineStyleGeometryModifier_PerlinNoise1D);
1012       break;
1013     case LS_MODIFIER_PERLIN_NOISE_2D:
1014       size = sizeof(LineStyleGeometryModifier_PerlinNoise2D);
1015       break;
1016     case LS_MODIFIER_BACKBONE_STRETCHER:
1017       size = sizeof(LineStyleGeometryModifier_BackboneStretcher);
1018       break;
1019     case LS_MODIFIER_TIP_REMOVER:
1020       size = sizeof(LineStyleGeometryModifier_TipRemover);
1021       break;
1022     case LS_MODIFIER_POLYGONIZATION:
1023       size = sizeof(LineStyleGeometryModifier_Polygonalization);
1024       break;
1025     case LS_MODIFIER_GUIDING_LINES:
1026       size = sizeof(LineStyleGeometryModifier_GuidingLines);
1027       break;
1028     case LS_MODIFIER_BLUEPRINT:
1029       size = sizeof(LineStyleGeometryModifier_Blueprint);
1030       break;
1031     case LS_MODIFIER_2D_OFFSET:
1032       size = sizeof(LineStyleGeometryModifier_2DOffset);
1033       break;
1034     case LS_MODIFIER_2D_TRANSFORM:
1035       size = sizeof(LineStyleGeometryModifier_2DTransform);
1036       break;
1037     case LS_MODIFIER_SIMPLIFICATION:
1038       size = sizeof(LineStyleGeometryModifier_Simplification);
1039       break;
1040     default:
1041       return NULL; /* unknown modifier type */
1042   }
1043
1044   return new_modifier(name, type, size);
1045 }
1046
1047 LineStyleModifier *BKE_linestyle_geometry_modifier_add(FreestyleLineStyle *linestyle,
1048                                                        const char *name,
1049                                                        int type)
1050 {
1051   LineStyleModifier *m;
1052
1053   m = alloc_geometry_modifier(name, type);
1054
1055   switch (type) {
1056     case LS_MODIFIER_SAMPLING: {
1057       LineStyleGeometryModifier_Sampling *p = (LineStyleGeometryModifier_Sampling *)m;
1058       p->sampling = 10.0f;
1059       break;
1060     }
1061     case LS_MODIFIER_BEZIER_CURVE: {
1062       LineStyleGeometryModifier_BezierCurve *p = (LineStyleGeometryModifier_BezierCurve *)m;
1063       p->error = 10.0f;
1064       break;
1065     }
1066     case LS_MODIFIER_SINUS_DISPLACEMENT: {
1067       LineStyleGeometryModifier_SinusDisplacement *p =
1068           (LineStyleGeometryModifier_SinusDisplacement *)m;
1069       p->wavelength = 20.0f;
1070       p->amplitude = 5.0f;
1071       p->phase = 0.0f;
1072       break;
1073     }
1074     case LS_MODIFIER_SPATIAL_NOISE: {
1075       LineStyleGeometryModifier_SpatialNoise *p = (LineStyleGeometryModifier_SpatialNoise *)m;
1076       p->amplitude = 5.0f;
1077       p->scale = 20.0f;
1078       p->octaves = 4;
1079       p->flags = LS_MODIFIER_SPATIAL_NOISE_SMOOTH | LS_MODIFIER_SPATIAL_NOISE_PURERANDOM;
1080       break;
1081     }
1082     case LS_MODIFIER_PERLIN_NOISE_1D: {
1083       LineStyleGeometryModifier_PerlinNoise1D *p = (LineStyleGeometryModifier_PerlinNoise1D *)m;
1084       p->frequency = 10.0f;
1085       p->amplitude = 10.0f;
1086       p->octaves = 4;
1087       p->angle = DEG2RADF(45.0f);
1088       break;
1089     }
1090     case LS_MODIFIER_PERLIN_NOISE_2D: {
1091       LineStyleGeometryModifier_PerlinNoise2D *p = (LineStyleGeometryModifier_PerlinNoise2D *)m;
1092       p->frequency = 10.0f;
1093       p->amplitude = 10.0f;
1094       p->octaves = 4;
1095       p->angle = DEG2RADF(45.0f);
1096       break;
1097     }
1098     case LS_MODIFIER_BACKBONE_STRETCHER: {
1099       LineStyleGeometryModifier_BackboneStretcher *p =
1100           (LineStyleGeometryModifier_BackboneStretcher *)m;
1101       p->backbone_length = 10.0f;
1102       break;
1103     }
1104     case LS_MODIFIER_TIP_REMOVER: {
1105       LineStyleGeometryModifier_TipRemover *p = (LineStyleGeometryModifier_TipRemover *)m;
1106       p->tip_length = 10.0f;
1107       break;
1108     }
1109     case LS_MODIFIER_POLYGONIZATION: {
1110       LineStyleGeometryModifier_Polygonalization *p =
1111           (LineStyleGeometryModifier_Polygonalization *)m;
1112       p->error = 10.0f;
1113       break;
1114     }
1115     case LS_MODIFIER_GUIDING_LINES: {
1116       LineStyleGeometryModifier_GuidingLines *p = (LineStyleGeometryModifier_GuidingLines *)m;
1117       p->offset = 0.0f;
1118       break;
1119     }
1120     case LS_MODIFIER_BLUEPRINT: {
1121       LineStyleGeometryModifier_Blueprint *p = (LineStyleGeometryModifier_Blueprint *)m;
1122       p->flags = LS_MODIFIER_BLUEPRINT_CIRCLES;
1123       p->rounds = 1;
1124       p->backbone_length = 10.0f;
1125       p->random_radius = 3;
1126       p->random_center = 5;
1127       p->random_backbone = 5;
1128       break;
1129     }
1130     case LS_MODIFIER_2D_OFFSET: {
1131       LineStyleGeometryModifier_2DOffset *p = (LineStyleGeometryModifier_2DOffset *)m;
1132       p->start = 0.0f;
1133       p->end = 0.0f;
1134       p->x = 0.0f;
1135       p->y = 0.0f;
1136       break;
1137     }
1138     case LS_MODIFIER_2D_TRANSFORM: {
1139       LineStyleGeometryModifier_2DTransform *p = (LineStyleGeometryModifier_2DTransform *)m;
1140       p->pivot = LS_MODIFIER_2D_TRANSFORM_PIVOT_CENTER;
1141       p->scale_x = 1.0f;
1142       p->scale_y = 1.0f;
1143       p->angle = DEG2RADF(0.0f);
1144       p->pivot_u = 0.5f;
1145       p->pivot_x = 0.0f;
1146       p->pivot_y = 0.0f;
1147       break;
1148     }
1149     case LS_MODIFIER_SIMPLIFICATION: {
1150       LineStyleGeometryModifier_Simplification *p = (LineStyleGeometryModifier_Simplification *)m;
1151       p->tolerance = 0.1f;
1152       break;
1153     }
1154     default:
1155       return NULL; /* unknown modifier type */
1156   }
1157   add_to_modifier_list(&linestyle->geometry_modifiers, m);
1158
1159   return m;
1160 }
1161
1162 LineStyleModifier *BKE_linestyle_geometry_modifier_copy(FreestyleLineStyle *linestyle,
1163                                                         const LineStyleModifier *m,
1164                                                         const int UNUSED(flag))
1165 {
1166   LineStyleModifier *new_m;
1167
1168   new_m = alloc_geometry_modifier(m->name, m->type);
1169   new_m->flags = m->flags;
1170
1171   switch (m->type) {
1172     case LS_MODIFIER_SAMPLING: {
1173       LineStyleGeometryModifier_Sampling *p = (LineStyleGeometryModifier_Sampling *)m;
1174       LineStyleGeometryModifier_Sampling *q = (LineStyleGeometryModifier_Sampling *)new_m;
1175       q->sampling = p->sampling;
1176       break;
1177     }
1178     case LS_MODIFIER_BEZIER_CURVE: {
1179       LineStyleGeometryModifier_BezierCurve *p = (LineStyleGeometryModifier_BezierCurve *)m;
1180       LineStyleGeometryModifier_BezierCurve *q = (LineStyleGeometryModifier_BezierCurve *)new_m;
1181       q->error = p->error;
1182       break;
1183     }
1184     case LS_MODIFIER_SINUS_DISPLACEMENT: {
1185       LineStyleGeometryModifier_SinusDisplacement *p =
1186           (LineStyleGeometryModifier_SinusDisplacement *)m;
1187       LineStyleGeometryModifier_SinusDisplacement *q =
1188           (LineStyleGeometryModifier_SinusDisplacement *)new_m;
1189       q->wavelength = p->wavelength;
1190       q->amplitude = p->amplitude;
1191       q->phase = p->phase;
1192       break;
1193     }
1194     case LS_MODIFIER_SPATIAL_NOISE: {
1195       LineStyleGeometryModifier_SpatialNoise *p = (LineStyleGeometryModifier_SpatialNoise *)m;
1196       LineStyleGeometryModifier_SpatialNoise *q = (LineStyleGeometryModifier_SpatialNoise *)new_m;
1197       q->amplitude = p->amplitude;
1198       q->scale = p->scale;
1199       q->octaves = p->octaves;
1200       q->flags = p->flags;
1201       break;
1202     }
1203     case LS_MODIFIER_PERLIN_NOISE_1D: {
1204       LineStyleGeometryModifier_PerlinNoise1D *p = (LineStyleGeometryModifier_PerlinNoise1D *)m;
1205       LineStyleGeometryModifier_PerlinNoise1D *q = (LineStyleGeometryModifier_PerlinNoise1D *)
1206           new_m;
1207       q->frequency = p->frequency;
1208       q->amplitude = p->amplitude;
1209       q->angle = p->angle;
1210       q->octaves = p->octaves;
1211       q->seed = p->seed;
1212       break;
1213     }
1214     case LS_MODIFIER_PERLIN_NOISE_2D: {
1215       LineStyleGeometryModifier_PerlinNoise2D *p = (LineStyleGeometryModifier_PerlinNoise2D *)m;
1216       LineStyleGeometryModifier_PerlinNoise2D *q = (LineStyleGeometryModifier_PerlinNoise2D *)
1217           new_m;
1218       q->frequency = p->frequency;
1219       q->amplitude = p->amplitude;
1220       q->angle = p->angle;
1221       q->octaves = p->octaves;
1222       q->seed = p->seed;
1223       break;
1224     }
1225     case LS_MODIFIER_BACKBONE_STRETCHER: {
1226       LineStyleGeometryModifier_BackboneStretcher *p =
1227           (LineStyleGeometryModifier_BackboneStretcher *)m;
1228       LineStyleGeometryModifier_BackboneStretcher *q =
1229           (LineStyleGeometryModifier_BackboneStretcher *)new_m;
1230       q->backbone_length = p->backbone_length;
1231       break;
1232     }
1233     case LS_MODIFIER_TIP_REMOVER: {
1234       LineStyleGeometryModifier_TipRemover *p = (LineStyleGeometryModifier_TipRemover *)m;
1235       LineStyleGeometryModifier_TipRemover *q = (LineStyleGeometryModifier_TipRemover *)new_m;
1236       q->tip_length = p->tip_length;
1237       break;
1238     }
1239     case LS_MODIFIER_POLYGONIZATION: {
1240       LineStyleGeometryModifier_Polygonalization *p =
1241           (LineStyleGeometryModifier_Polygonalization *)m;
1242       LineStyleGeometryModifier_Polygonalization *q =
1243           (LineStyleGeometryModifier_Polygonalization *)new_m;
1244       q->error = p->error;
1245       break;
1246     }
1247     case LS_MODIFIER_GUIDING_LINES: {
1248       LineStyleGeometryModifier_GuidingLines *p = (LineStyleGeometryModifier_GuidingLines *)m;
1249       LineStyleGeometryModifier_GuidingLines *q = (LineStyleGeometryModifier_GuidingLines *)new_m;
1250       q->offset = p->offset;
1251       break;
1252     }
1253     case LS_MODIFIER_BLUEPRINT: {
1254       LineStyleGeometryModifier_Blueprint *p = (LineStyleGeometryModifier_Blueprint *)m;
1255       LineStyleGeometryModifier_Blueprint *q = (LineStyleGeometryModifier_Blueprint *)new_m;
1256       q->flags = p->flags;
1257       q->rounds = p->rounds;
1258       q->backbone_length = p->backbone_length;
1259       q->random_radius = p->random_radius;
1260       q->random_center = p->random_center;
1261       q->random_backbone = p->random_backbone;
1262       break;
1263     }
1264     case LS_MODIFIER_2D_OFFSET: {
1265       LineStyleGeometryModifier_2DOffset *p = (LineStyleGeometryModifier_2DOffset *)m;
1266       LineStyleGeometryModifier_2DOffset *q = (LineStyleGeometryModifier_2DOffset *)new_m;
1267       q->start = p->start;
1268       q->end = p->end;
1269       q->x = p->x;
1270       q->y = p->y;
1271       break;
1272     }
1273     case LS_MODIFIER_2D_TRANSFORM: {
1274       LineStyleGeometryModifier_2DTransform *p = (LineStyleGeometryModifier_2DTransform *)m;
1275       LineStyleGeometryModifier_2DTransform *q = (LineStyleGeometryModifier_2DTransform *)new_m;
1276       q->pivot = p->pivot;
1277       q->scale_x = p->scale_x;
1278       q->scale_y = p->scale_y;
1279       q->angle = p->angle;
1280       q->pivot_u = p->pivot_u;
1281       q->pivot_x = p->pivot_x;
1282       q->pivot_y = p->pivot_y;
1283       break;
1284     }
1285     case LS_MODIFIER_SIMPLIFICATION: {
1286       LineStyleGeometryModifier_Simplification *p = (LineStyleGeometryModifier_Simplification *)m;
1287       LineStyleGeometryModifier_Simplification *q = (LineStyleGeometryModifier_Simplification *)
1288           new_m;
1289       q->tolerance = p->tolerance;
1290       break;
1291     }
1292     default:
1293       return NULL; /* unknown modifier type */
1294   }
1295   add_to_modifier_list(&linestyle->geometry_modifiers, new_m);
1296
1297   return new_m;
1298 }
1299
1300 int BKE_linestyle_geometry_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *m)
1301 {
1302   if (BLI_findindex(&linestyle->geometry_modifiers, m) == -1) {
1303     return -1;
1304   }
1305   BLI_freelinkN(&linestyle->geometry_modifiers, m);
1306   return 0;
1307 }
1308
1309 /**
1310  * Reinsert \a modifier in modifier list with an offset of \a direction.
1311  * \return if position of \a modifier has changed.
1312  */
1313 bool BKE_linestyle_color_modifier_move(FreestyleLineStyle *linestyle,
1314                                        LineStyleModifier *modifier,
1315                                        int direction)
1316 {
1317   return BLI_listbase_link_move(&linestyle->color_modifiers, modifier, direction);
1318 }
1319 bool BKE_linestyle_alpha_modifier_move(FreestyleLineStyle *linestyle,
1320                                        LineStyleModifier *modifier,
1321                                        int direction)
1322 {
1323   return BLI_listbase_link_move(&linestyle->alpha_modifiers, modifier, direction);
1324 }
1325 bool BKE_linestyle_thickness_modifier_move(FreestyleLineStyle *linestyle,
1326                                            LineStyleModifier *modifier,
1327                                            int direction)
1328 {
1329   return BLI_listbase_link_move(&linestyle->thickness_modifiers, modifier, direction);
1330 }
1331 bool BKE_linestyle_geometry_modifier_move(FreestyleLineStyle *linestyle,
1332                                           LineStyleModifier *modifier,
1333                                           int direction)
1334 {
1335   return BLI_listbase_link_move(&linestyle->geometry_modifiers, modifier, direction);
1336 }
1337
1338 void BKE_linestyle_modifier_list_color_ramps(FreestyleLineStyle *linestyle, ListBase *listbase)
1339 {
1340   LineStyleModifier *m;
1341   ColorBand *color_ramp;
1342   LinkData *link;
1343
1344   BLI_listbase_clear(listbase);
1345
1346   for (m = (LineStyleModifier *)linestyle->color_modifiers.first; m; m = m->next) {
1347     switch (m->type) {
1348       case LS_MODIFIER_ALONG_STROKE:
1349         color_ramp = ((LineStyleColorModifier_AlongStroke *)m)->color_ramp;
1350         break;
1351       case LS_MODIFIER_DISTANCE_FROM_CAMERA:
1352         color_ramp = ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp;
1353         break;
1354       case LS_MODIFIER_DISTANCE_FROM_OBJECT:
1355         color_ramp = ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp;
1356         break;
1357       case LS_MODIFIER_MATERIAL:
1358         color_ramp = ((LineStyleColorModifier_Material *)m)->color_ramp;
1359         break;
1360       default:
1361         continue;
1362     }
1363     link = (LinkData *)MEM_callocN(sizeof(LinkData), "link to color ramp");
1364     link->data = color_ramp;
1365     BLI_addtail(listbase, link);
1366   }
1367 }
1368
1369 char *BKE_linestyle_path_to_color_ramp(FreestyleLineStyle *linestyle, ColorBand *color_ramp)
1370 {
1371   LineStyleModifier *m;
1372   bool found = false;
1373
1374   for (m = (LineStyleModifier *)linestyle->color_modifiers.first; m; m = m->next) {
1375     switch (m->type) {
1376       case LS_MODIFIER_ALONG_STROKE:
1377         if (color_ramp == ((LineStyleColorModifier_AlongStroke *)m)->color_ramp) {
1378           found = true;
1379         }
1380         break;
1381       case LS_MODIFIER_DISTANCE_FROM_CAMERA:
1382         if (color_ramp == ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp) {
1383           found = true;
1384         }
1385         break;
1386       case LS_MODIFIER_DISTANCE_FROM_OBJECT:
1387         if (color_ramp == ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp) {
1388           found = true;
1389         }
1390         break;
1391       case LS_MODIFIER_MATERIAL:
1392         if (color_ramp == ((LineStyleColorModifier_Material *)m)->color_ramp) {
1393           found = true;
1394         }
1395         break;
1396       case LS_MODIFIER_TANGENT:
1397         if (color_ramp == ((LineStyleColorModifier_Tangent *)m)->color_ramp) {
1398           found = true;
1399         }
1400         break;
1401       case LS_MODIFIER_NOISE:
1402         if (color_ramp == ((LineStyleColorModifier_Noise *)m)->color_ramp) {
1403           found = true;
1404         }
1405         break;
1406       case LS_MODIFIER_CREASE_ANGLE:
1407         if (color_ramp == ((LineStyleColorModifier_CreaseAngle *)m)->color_ramp) {
1408           found = true;
1409         }
1410         break;
1411       case LS_MODIFIER_CURVATURE_3D:
1412         if (color_ramp == ((LineStyleColorModifier_Curvature_3D *)m)->color_ramp) {
1413           found = true;
1414         }
1415         break;
1416     }
1417
1418     if (found) {
1419       char name_esc[sizeof(m->name) * 2];
1420       BLI_strescape(name_esc, m->name, sizeof(name_esc));
1421       return BLI_sprintfN("color_modifiers[\"%s\"].color_ramp", name_esc);
1422     }
1423   }
1424   printf("BKE_linestyle_path_to_color_ramp: No color ramps correspond to the given pointer.\n");
1425   return NULL;
1426 }
1427
1428 bool BKE_linestyle_use_textures(FreestyleLineStyle *linestyle, const bool use_shading_nodes)
1429 {
1430   if (use_shading_nodes) {
1431     if (linestyle && linestyle->use_nodes && linestyle->nodetree) {
1432       bNode *node;
1433
1434       for (node = linestyle->nodetree->nodes.first; node; node = node->next) {
1435         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE) {
1436           return true;
1437         }
1438       }
1439     }
1440   }
1441   else {
1442     if (linestyle && (linestyle->flag & LS_TEXTURE)) {
1443       return (linestyle->mtex[0] != NULL);
1444     }
1445   }
1446   return false;
1447 }
1448
1449 void BKE_linestyle_default_shader(const bContext *C, FreestyleLineStyle *linestyle)
1450 {
1451   bNode *uv_along_stroke, *input_texure, *output_linestyle;
1452   bNodeSocket *fromsock, *tosock;
1453   bNodeTree *ntree;
1454
1455   BLI_assert(linestyle->nodetree == NULL);
1456
1457   ntree = ntreeAddTree(NULL, "stroke_shader", "ShaderNodeTree");
1458
1459   linestyle->nodetree = ntree;
1460
1461   uv_along_stroke = nodeAddStaticNode(C, ntree, SH_NODE_UVALONGSTROKE);
1462   uv_along_stroke->locx = 0.0f;
1463   uv_along_stroke->locy = 300.0f;
1464   uv_along_stroke->custom1 = 0;  // use_tips
1465
1466   input_texure = nodeAddStaticNode(C, ntree, SH_NODE_TEX_IMAGE);
1467   input_texure->locx = 200.0f;
1468   input_texure->locy = 300.0f;
1469
1470   output_linestyle = nodeAddStaticNode(C, ntree, SH_NODE_OUTPUT_LINESTYLE);
1471   output_linestyle->locx = 400.0f;
1472   output_linestyle->locy = 300.0f;
1473   output_linestyle->custom1 = MA_RAMP_BLEND;
1474   output_linestyle->custom2 = 0;  // use_clamp
1475
1476   nodeSetActive(ntree, input_texure);
1477
1478   fromsock = BLI_findlink(&uv_along_stroke->outputs, 0);  // UV
1479   tosock = BLI_findlink(&input_texure->inputs, 0);        // UV
1480   nodeAddLink(ntree, uv_along_stroke, fromsock, input_texure, tosock);
1481
1482   fromsock = BLI_findlink(&input_texure->outputs, 0);   // Color
1483   tosock = BLI_findlink(&output_linestyle->inputs, 0);  // Color
1484   nodeAddLink(ntree, input_texure, fromsock, output_linestyle, tosock);
1485
1486   ntreeUpdateTree(CTX_data_main(C), ntree);
1487 }