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