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