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_defaults.h"
31 #include "DNA_material_types.h" /* for ramp blend */
32 #include "DNA_object_types.h"
33 #include "DNA_texture_types.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 "BLT_translation.h"
41
42 #include "BKE_anim_data.h"
43 #include "BKE_colorband.h"
44 #include "BKE_colortools.h"
45 #include "BKE_context.h"
46 #include "BKE_freestyle.h"
47 #include "BKE_idtype.h"
48 #include "BKE_lib_id.h"
49 #include "BKE_lib_query.h"
50 #include "BKE_linestyle.h"
51 #include "BKE_main.h"
52 #include "BKE_node.h"
53 #include "BKE_texture.h"
54
55 #include "BLO_read_write.h"
56
linestyle_init_data(ID * id)57 static void linestyle_init_data(ID *id)
58 {
59 FreestyleLineStyle *linestyle = (FreestyleLineStyle *)id;
60
61 BLI_assert(MEMCMP_STRUCT_AFTER_IS_ZERO(linestyle, id));
62
63 MEMCPY_STRUCT_AFTER(linestyle, DNA_struct_default_get(FreestyleLineStyle), id);
64
65 BKE_linestyle_geometry_modifier_add(linestyle, NULL, LS_MODIFIER_SAMPLING);
66 }
67
linestyle_copy_data(Main * bmain,ID * id_dst,const ID * id_src,const int flag)68 static void linestyle_copy_data(Main *bmain, ID *id_dst, const ID *id_src, const int flag)
69 {
70 FreestyleLineStyle *linestyle_dst = (FreestyleLineStyle *)id_dst;
71 const FreestyleLineStyle *linestyle_src = (const FreestyleLineStyle *)id_src;
72
73 /* We never handle usercount here for own data. */
74 const int flag_subdata = flag | LIB_ID_CREATE_NO_USER_REFCOUNT;
75 /* We always need allocation of our private ID data. */
76 const int flag_private_id_data = flag & ~LIB_ID_CREATE_NO_ALLOCATE;
77
78 for (int a = 0; a < MAX_MTEX; a++) {
79 if (linestyle_src->mtex[a]) {
80 linestyle_dst->mtex[a] = MEM_mallocN(sizeof(*linestyle_dst->mtex[a]), __func__);
81 *linestyle_dst->mtex[a] = *linestyle_src->mtex[a];
82 }
83 }
84
85 if (linestyle_src->nodetree) {
86 BKE_id_copy_ex(bmain,
87 (ID *)linestyle_src->nodetree,
88 (ID **)&linestyle_dst->nodetree,
89 flag_private_id_data);
90 }
91
92 LineStyleModifier *linestyle_modifier;
93 BLI_listbase_clear(&linestyle_dst->color_modifiers);
94 for (linestyle_modifier = (LineStyleModifier *)linestyle_src->color_modifiers.first;
95 linestyle_modifier;
96 linestyle_modifier = linestyle_modifier->next) {
97 BKE_linestyle_color_modifier_copy(linestyle_dst, linestyle_modifier, flag_subdata);
98 }
99
100 BLI_listbase_clear(&linestyle_dst->alpha_modifiers);
101 for (linestyle_modifier = (LineStyleModifier *)linestyle_src->alpha_modifiers.first;
102 linestyle_modifier;
103 linestyle_modifier = linestyle_modifier->next) {
104 BKE_linestyle_alpha_modifier_copy(linestyle_dst, linestyle_modifier, flag_subdata);
105 }
106
107 BLI_listbase_clear(&linestyle_dst->thickness_modifiers);
108 for (linestyle_modifier = (LineStyleModifier *)linestyle_src->thickness_modifiers.first;
109 linestyle_modifier;
110 linestyle_modifier = linestyle_modifier->next) {
111 BKE_linestyle_thickness_modifier_copy(linestyle_dst, linestyle_modifier, flag_subdata);
112 }
113
114 BLI_listbase_clear(&linestyle_dst->geometry_modifiers);
115 for (linestyle_modifier = (LineStyleModifier *)linestyle_src->geometry_modifiers.first;
116 linestyle_modifier;
117 linestyle_modifier = linestyle_modifier->next) {
118 BKE_linestyle_geometry_modifier_copy(linestyle_dst, linestyle_modifier, flag_subdata);
119 }
120 }
121
linestyle_free_data(ID * id)122 static void linestyle_free_data(ID *id)
123 {
124 FreestyleLineStyle *linestyle = (FreestyleLineStyle *)id;
125 LineStyleModifier *linestyle_modifier;
126
127 for (int material_slot_index = 0; material_slot_index < MAX_MTEX; material_slot_index++) {
128 MEM_SAFE_FREE(linestyle->mtex[material_slot_index]);
129 }
130
131 /* is no lib link block, but linestyle extension */
132 if (linestyle->nodetree) {
133 ntreeFreeEmbeddedTree(linestyle->nodetree);
134 MEM_freeN(linestyle->nodetree);
135 linestyle->nodetree = NULL;
136 }
137
138 while ((linestyle_modifier = (LineStyleModifier *)linestyle->color_modifiers.first)) {
139 BKE_linestyle_color_modifier_remove(linestyle, linestyle_modifier);
140 }
141 while ((linestyle_modifier = (LineStyleModifier *)linestyle->alpha_modifiers.first)) {
142 BKE_linestyle_alpha_modifier_remove(linestyle, linestyle_modifier);
143 }
144 while ((linestyle_modifier = (LineStyleModifier *)linestyle->thickness_modifiers.first)) {
145 BKE_linestyle_thickness_modifier_remove(linestyle, linestyle_modifier);
146 }
147 while ((linestyle_modifier = (LineStyleModifier *)linestyle->geometry_modifiers.first)) {
148 BKE_linestyle_geometry_modifier_remove(linestyle, linestyle_modifier);
149 }
150 }
151
linestyle_foreach_id(ID * id,LibraryForeachIDData * data)152 static void linestyle_foreach_id(ID *id, LibraryForeachIDData *data)
153 {
154 FreestyleLineStyle *linestyle = (FreestyleLineStyle *)id;
155
156 for (int i = 0; i < MAX_MTEX; i++) {
157 if (linestyle->mtex[i]) {
158 BKE_texture_mtex_foreach_id(data, linestyle->mtex[i]);
159 }
160 }
161 if (linestyle->nodetree) {
162 /* nodetree **are owned by IDs**, treat them as mere sub-data and not real ID! */
163 BKE_library_foreach_ID_embedded(data, (ID **)&linestyle->nodetree);
164 }
165
166 LISTBASE_FOREACH (LineStyleModifier *, lsm, &linestyle->color_modifiers) {
167 if (lsm->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
168 LineStyleColorModifier_DistanceFromObject *p = (LineStyleColorModifier_DistanceFromObject *)
169 lsm;
170 if (p->target) {
171 BKE_LIB_FOREACHID_PROCESS(data, p->target, IDWALK_CB_NOP);
172 }
173 }
174 }
175 LISTBASE_FOREACH (LineStyleModifier *, lsm, &linestyle->alpha_modifiers) {
176 if (lsm->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
177 LineStyleAlphaModifier_DistanceFromObject *p = (LineStyleAlphaModifier_DistanceFromObject *)
178 lsm;
179 if (p->target) {
180 BKE_LIB_FOREACHID_PROCESS(data, p->target, IDWALK_CB_NOP);
181 }
182 }
183 }
184 LISTBASE_FOREACH (LineStyleModifier *, lsm, &linestyle->thickness_modifiers) {
185 if (lsm->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
186 LineStyleThicknessModifier_DistanceFromObject *p =
187 (LineStyleThicknessModifier_DistanceFromObject *)lsm;
188 if (p->target) {
189 BKE_LIB_FOREACHID_PROCESS(data, p->target, IDWALK_CB_NOP);
190 }
191 }
192 }
193 }
194
write_linestyle_color_modifiers(BlendWriter * writer,ListBase * modifiers)195 static void write_linestyle_color_modifiers(BlendWriter *writer, ListBase *modifiers)
196 {
197 LineStyleModifier *m;
198
199 for (m = modifiers->first; m; m = m->next) {
200 int struct_nr;
201 switch (m->type) {
202 case LS_MODIFIER_ALONG_STROKE:
203 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleColorModifier_AlongStroke);
204 break;
205 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
206 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleColorModifier_DistanceFromCamera);
207 break;
208 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
209 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleColorModifier_DistanceFromObject);
210 break;
211 case LS_MODIFIER_MATERIAL:
212 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleColorModifier_Material);
213 break;
214 case LS_MODIFIER_TANGENT:
215 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleColorModifier_Tangent);
216 break;
217 case LS_MODIFIER_NOISE:
218 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleColorModifier_Noise);
219 break;
220 case LS_MODIFIER_CREASE_ANGLE:
221 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleColorModifier_CreaseAngle);
222 break;
223 case LS_MODIFIER_CURVATURE_3D:
224 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleColorModifier_Curvature_3D);
225 break;
226 default:
227 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleModifier); /* this should not happen */
228 }
229 BLO_write_struct_by_id(writer, struct_nr, m);
230 }
231 for (m = modifiers->first; m; m = m->next) {
232 switch (m->type) {
233 case LS_MODIFIER_ALONG_STROKE:
234 BLO_write_struct(writer, ColorBand, ((LineStyleColorModifier_AlongStroke *)m)->color_ramp);
235 break;
236 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
237 BLO_write_struct(
238 writer, ColorBand, ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp);
239 break;
240 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
241 BLO_write_struct(
242 writer, ColorBand, ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp);
243 break;
244 case LS_MODIFIER_MATERIAL:
245 BLO_write_struct(writer, ColorBand, ((LineStyleColorModifier_Material *)m)->color_ramp);
246 break;
247 case LS_MODIFIER_TANGENT:
248 BLO_write_struct(writer, ColorBand, ((LineStyleColorModifier_Tangent *)m)->color_ramp);
249 break;
250 case LS_MODIFIER_NOISE:
251 BLO_write_struct(writer, ColorBand, ((LineStyleColorModifier_Noise *)m)->color_ramp);
252 break;
253 case LS_MODIFIER_CREASE_ANGLE:
254 BLO_write_struct(writer, ColorBand, ((LineStyleColorModifier_CreaseAngle *)m)->color_ramp);
255 break;
256 case LS_MODIFIER_CURVATURE_3D:
257 BLO_write_struct(
258 writer, ColorBand, ((LineStyleColorModifier_Curvature_3D *)m)->color_ramp);
259 break;
260 }
261 }
262 }
263
write_linestyle_alpha_modifiers(BlendWriter * writer,ListBase * modifiers)264 static void write_linestyle_alpha_modifiers(BlendWriter *writer, ListBase *modifiers)
265 {
266 LineStyleModifier *m;
267
268 for (m = modifiers->first; m; m = m->next) {
269 int struct_nr;
270 switch (m->type) {
271 case LS_MODIFIER_ALONG_STROKE:
272 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleAlphaModifier_AlongStroke);
273 break;
274 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
275 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleAlphaModifier_DistanceFromCamera);
276 break;
277 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
278 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleAlphaModifier_DistanceFromObject);
279 break;
280 case LS_MODIFIER_MATERIAL:
281 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleAlphaModifier_Material);
282 break;
283 case LS_MODIFIER_TANGENT:
284 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleAlphaModifier_Tangent);
285 break;
286 case LS_MODIFIER_NOISE:
287 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleAlphaModifier_Noise);
288 break;
289 case LS_MODIFIER_CREASE_ANGLE:
290 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleAlphaModifier_CreaseAngle);
291 break;
292 case LS_MODIFIER_CURVATURE_3D:
293 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleAlphaModifier_Curvature_3D);
294 break;
295 default:
296 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleModifier); /* this should not happen */
297 }
298 BLO_write_struct_by_id(writer, struct_nr, m);
299 }
300 for (m = modifiers->first; m; m = m->next) {
301 switch (m->type) {
302 case LS_MODIFIER_ALONG_STROKE:
303 BKE_curvemapping_blend_write(writer, ((LineStyleAlphaModifier_AlongStroke *)m)->curve);
304 break;
305 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
306 BKE_curvemapping_blend_write(writer,
307 ((LineStyleAlphaModifier_DistanceFromCamera *)m)->curve);
308 break;
309 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
310 BKE_curvemapping_blend_write(writer,
311 ((LineStyleAlphaModifier_DistanceFromObject *)m)->curve);
312 break;
313 case LS_MODIFIER_MATERIAL:
314 BKE_curvemapping_blend_write(writer, ((LineStyleAlphaModifier_Material *)m)->curve);
315 break;
316 case LS_MODIFIER_TANGENT:
317 BKE_curvemapping_blend_write(writer, ((LineStyleAlphaModifier_Tangent *)m)->curve);
318 break;
319 case LS_MODIFIER_NOISE:
320 BKE_curvemapping_blend_write(writer, ((LineStyleAlphaModifier_Noise *)m)->curve);
321 break;
322 case LS_MODIFIER_CREASE_ANGLE:
323 BKE_curvemapping_blend_write(writer, ((LineStyleAlphaModifier_CreaseAngle *)m)->curve);
324 break;
325 case LS_MODIFIER_CURVATURE_3D:
326 BKE_curvemapping_blend_write(writer, ((LineStyleAlphaModifier_Curvature_3D *)m)->curve);
327 break;
328 }
329 }
330 }
331
write_linestyle_thickness_modifiers(BlendWriter * writer,ListBase * modifiers)332 static void write_linestyle_thickness_modifiers(BlendWriter *writer, ListBase *modifiers)
333 {
334 LineStyleModifier *m;
335
336 for (m = modifiers->first; m; m = m->next) {
337 int struct_nr;
338 switch (m->type) {
339 case LS_MODIFIER_ALONG_STROKE:
340 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_AlongStroke);
341 break;
342 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
343 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_DistanceFromCamera);
344 break;
345 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
346 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_DistanceFromObject);
347 break;
348 case LS_MODIFIER_MATERIAL:
349 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_Material);
350 break;
351 case LS_MODIFIER_CALLIGRAPHY:
352 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_Calligraphy);
353 break;
354 case LS_MODIFIER_TANGENT:
355 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_Tangent);
356 break;
357 case LS_MODIFIER_NOISE:
358 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_Noise);
359 break;
360 case LS_MODIFIER_CREASE_ANGLE:
361 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_CreaseAngle);
362 break;
363 case LS_MODIFIER_CURVATURE_3D:
364 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_Curvature_3D);
365 break;
366 default:
367 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleModifier); /* this should not happen */
368 }
369 BLO_write_struct_by_id(writer, struct_nr, m);
370 }
371 for (m = modifiers->first; m; m = m->next) {
372 switch (m->type) {
373 case LS_MODIFIER_ALONG_STROKE:
374 BKE_curvemapping_blend_write(writer, ((LineStyleThicknessModifier_AlongStroke *)m)->curve);
375 break;
376 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
377 BKE_curvemapping_blend_write(writer,
378 ((LineStyleThicknessModifier_DistanceFromCamera *)m)->curve);
379 break;
380 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
381 BKE_curvemapping_blend_write(writer,
382 ((LineStyleThicknessModifier_DistanceFromObject *)m)->curve);
383 break;
384 case LS_MODIFIER_MATERIAL:
385 BKE_curvemapping_blend_write(writer, ((LineStyleThicknessModifier_Material *)m)->curve);
386 break;
387 case LS_MODIFIER_TANGENT:
388 BKE_curvemapping_blend_write(writer, ((LineStyleThicknessModifier_Tangent *)m)->curve);
389 break;
390 case LS_MODIFIER_CREASE_ANGLE:
391 BKE_curvemapping_blend_write(writer, ((LineStyleThicknessModifier_CreaseAngle *)m)->curve);
392 break;
393 case LS_MODIFIER_CURVATURE_3D:
394 BKE_curvemapping_blend_write(writer,
395 ((LineStyleThicknessModifier_Curvature_3D *)m)->curve);
396 break;
397 }
398 }
399 }
400
write_linestyle_geometry_modifiers(BlendWriter * writer,ListBase * modifiers)401 static void write_linestyle_geometry_modifiers(BlendWriter *writer, ListBase *modifiers)
402 {
403 LineStyleModifier *m;
404
405 for (m = modifiers->first; m; m = m->next) {
406 int struct_nr;
407 switch (m->type) {
408 case LS_MODIFIER_SAMPLING:
409 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_Sampling);
410 break;
411 case LS_MODIFIER_BEZIER_CURVE:
412 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_BezierCurve);
413 break;
414 case LS_MODIFIER_SINUS_DISPLACEMENT:
415 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_SinusDisplacement);
416 break;
417 case LS_MODIFIER_SPATIAL_NOISE:
418 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_SpatialNoise);
419 break;
420 case LS_MODIFIER_PERLIN_NOISE_1D:
421 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_PerlinNoise1D);
422 break;
423 case LS_MODIFIER_PERLIN_NOISE_2D:
424 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_PerlinNoise2D);
425 break;
426 case LS_MODIFIER_BACKBONE_STRETCHER:
427 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_BackboneStretcher);
428 break;
429 case LS_MODIFIER_TIP_REMOVER:
430 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_TipRemover);
431 break;
432 case LS_MODIFIER_POLYGONIZATION:
433 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_Polygonalization);
434 break;
435 case LS_MODIFIER_GUIDING_LINES:
436 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_GuidingLines);
437 break;
438 case LS_MODIFIER_BLUEPRINT:
439 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_Blueprint);
440 break;
441 case LS_MODIFIER_2D_OFFSET:
442 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_2DOffset);
443 break;
444 case LS_MODIFIER_2D_TRANSFORM:
445 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_2DTransform);
446 break;
447 case LS_MODIFIER_SIMPLIFICATION:
448 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_Simplification);
449 break;
450 default:
451 struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleModifier); /* this should not happen */
452 }
453 BLO_write_struct_by_id(writer, struct_nr, m);
454 }
455 }
456
linestyle_blend_write(BlendWriter * writer,ID * id,const void * id_address)457 static void linestyle_blend_write(BlendWriter *writer, ID *id, const void *id_address)
458 {
459 FreestyleLineStyle *linestyle = (FreestyleLineStyle *)id;
460 if (linestyle->id.us > 0 || BLO_write_is_undo(writer)) {
461 BLO_write_id_struct(writer, FreestyleLineStyle, id_address, &linestyle->id);
462 BKE_id_blend_write(writer, &linestyle->id);
463
464 if (linestyle->adt) {
465 BKE_animdata_blend_write(writer, linestyle->adt);
466 }
467
468 write_linestyle_color_modifiers(writer, &linestyle->color_modifiers);
469 write_linestyle_alpha_modifiers(writer, &linestyle->alpha_modifiers);
470 write_linestyle_thickness_modifiers(writer, &linestyle->thickness_modifiers);
471 write_linestyle_geometry_modifiers(writer, &linestyle->geometry_modifiers);
472 for (int a = 0; a < MAX_MTEX; a++) {
473 if (linestyle->mtex[a]) {
474 BLO_write_struct(writer, MTex, linestyle->mtex[a]);
475 }
476 }
477 if (linestyle->nodetree) {
478 BLO_write_struct(writer, bNodeTree, linestyle->nodetree);
479 ntreeBlendWrite(writer, linestyle->nodetree);
480 }
481 }
482 }
483
direct_link_linestyle_color_modifier(BlendDataReader * reader,LineStyleModifier * modifier)484 static void direct_link_linestyle_color_modifier(BlendDataReader *reader,
485 LineStyleModifier *modifier)
486 {
487 switch (modifier->type) {
488 case LS_MODIFIER_ALONG_STROKE: {
489 LineStyleColorModifier_AlongStroke *m = (LineStyleColorModifier_AlongStroke *)modifier;
490 BLO_read_data_address(reader, &m->color_ramp);
491 break;
492 }
493 case LS_MODIFIER_DISTANCE_FROM_CAMERA: {
494 LineStyleColorModifier_DistanceFromCamera *m = (LineStyleColorModifier_DistanceFromCamera *)
495 modifier;
496 BLO_read_data_address(reader, &m->color_ramp);
497 break;
498 }
499 case LS_MODIFIER_DISTANCE_FROM_OBJECT: {
500 LineStyleColorModifier_DistanceFromObject *m = (LineStyleColorModifier_DistanceFromObject *)
501 modifier;
502 BLO_read_data_address(reader, &m->color_ramp);
503 break;
504 }
505 case LS_MODIFIER_MATERIAL: {
506 LineStyleColorModifier_Material *m = (LineStyleColorModifier_Material *)modifier;
507 BLO_read_data_address(reader, &m->color_ramp);
508 break;
509 }
510 case LS_MODIFIER_TANGENT: {
511 LineStyleColorModifier_Tangent *m = (LineStyleColorModifier_Tangent *)modifier;
512 BLO_read_data_address(reader, &m->color_ramp);
513 break;
514 }
515 case LS_MODIFIER_NOISE: {
516 LineStyleColorModifier_Noise *m = (LineStyleColorModifier_Noise *)modifier;
517 BLO_read_data_address(reader, &m->color_ramp);
518 break;
519 }
520 case LS_MODIFIER_CREASE_ANGLE: {
521 LineStyleColorModifier_CreaseAngle *m = (LineStyleColorModifier_CreaseAngle *)modifier;
522 BLO_read_data_address(reader, &m->color_ramp);
523 break;
524 }
525 case LS_MODIFIER_CURVATURE_3D: {
526 LineStyleColorModifier_Curvature_3D *m = (LineStyleColorModifier_Curvature_3D *)modifier;
527 BLO_read_data_address(reader, &m->color_ramp);
528 break;
529 }
530 }
531 }
532
direct_link_linestyle_alpha_modifier(BlendDataReader * reader,LineStyleModifier * modifier)533 static void direct_link_linestyle_alpha_modifier(BlendDataReader *reader,
534 LineStyleModifier *modifier)
535 {
536 switch (modifier->type) {
537 case LS_MODIFIER_ALONG_STROKE: {
538 LineStyleAlphaModifier_AlongStroke *m = (LineStyleAlphaModifier_AlongStroke *)modifier;
539 BLO_read_data_address(reader, &m->curve);
540 BKE_curvemapping_blend_read(reader, m->curve);
541 break;
542 }
543 case LS_MODIFIER_DISTANCE_FROM_CAMERA: {
544 LineStyleAlphaModifier_DistanceFromCamera *m = (LineStyleAlphaModifier_DistanceFromCamera *)
545 modifier;
546 BLO_read_data_address(reader, &m->curve);
547 BKE_curvemapping_blend_read(reader, m->curve);
548 break;
549 }
550 case LS_MODIFIER_DISTANCE_FROM_OBJECT: {
551 LineStyleAlphaModifier_DistanceFromObject *m = (LineStyleAlphaModifier_DistanceFromObject *)
552 modifier;
553 BLO_read_data_address(reader, &m->curve);
554 BKE_curvemapping_blend_read(reader, m->curve);
555 break;
556 }
557 case LS_MODIFIER_MATERIAL: {
558 LineStyleAlphaModifier_Material *m = (LineStyleAlphaModifier_Material *)modifier;
559 BLO_read_data_address(reader, &m->curve);
560 BKE_curvemapping_blend_read(reader, m->curve);
561 break;
562 }
563 case LS_MODIFIER_TANGENT: {
564 LineStyleAlphaModifier_Tangent *m = (LineStyleAlphaModifier_Tangent *)modifier;
565 BLO_read_data_address(reader, &m->curve);
566 BKE_curvemapping_blend_read(reader, m->curve);
567 break;
568 }
569 case LS_MODIFIER_NOISE: {
570 LineStyleAlphaModifier_Noise *m = (LineStyleAlphaModifier_Noise *)modifier;
571 BLO_read_data_address(reader, &m->curve);
572 BKE_curvemapping_blend_read(reader, m->curve);
573 break;
574 }
575 case LS_MODIFIER_CREASE_ANGLE: {
576 LineStyleAlphaModifier_CreaseAngle *m = (LineStyleAlphaModifier_CreaseAngle *)modifier;
577 BLO_read_data_address(reader, &m->curve);
578 BKE_curvemapping_blend_read(reader, m->curve);
579 break;
580 }
581 case LS_MODIFIER_CURVATURE_3D: {
582 LineStyleAlphaModifier_Curvature_3D *m = (LineStyleAlphaModifier_Curvature_3D *)modifier;
583 BLO_read_data_address(reader, &m->curve);
584 BKE_curvemapping_blend_read(reader, m->curve);
585 break;
586 }
587 }
588 }
589
direct_link_linestyle_thickness_modifier(BlendDataReader * reader,LineStyleModifier * modifier)590 static void direct_link_linestyle_thickness_modifier(BlendDataReader *reader,
591 LineStyleModifier *modifier)
592 {
593 switch (modifier->type) {
594 case LS_MODIFIER_ALONG_STROKE: {
595 LineStyleThicknessModifier_AlongStroke *m = (LineStyleThicknessModifier_AlongStroke *)
596 modifier;
597 BLO_read_data_address(reader, &m->curve);
598 BKE_curvemapping_blend_read(reader, m->curve);
599 break;
600 }
601 case LS_MODIFIER_DISTANCE_FROM_CAMERA: {
602 LineStyleThicknessModifier_DistanceFromCamera *m =
603 (LineStyleThicknessModifier_DistanceFromCamera *)modifier;
604 BLO_read_data_address(reader, &m->curve);
605 BKE_curvemapping_blend_read(reader, m->curve);
606 break;
607 }
608 case LS_MODIFIER_DISTANCE_FROM_OBJECT: {
609 LineStyleThicknessModifier_DistanceFromObject *m =
610 (LineStyleThicknessModifier_DistanceFromObject *)modifier;
611 BLO_read_data_address(reader, &m->curve);
612 BKE_curvemapping_blend_read(reader, m->curve);
613 break;
614 }
615 case LS_MODIFIER_MATERIAL: {
616 LineStyleThicknessModifier_Material *m = (LineStyleThicknessModifier_Material *)modifier;
617 BLO_read_data_address(reader, &m->curve);
618 BKE_curvemapping_blend_read(reader, m->curve);
619 break;
620 }
621 case LS_MODIFIER_TANGENT: {
622 LineStyleThicknessModifier_Tangent *m = (LineStyleThicknessModifier_Tangent *)modifier;
623 BLO_read_data_address(reader, &m->curve);
624 BKE_curvemapping_blend_read(reader, m->curve);
625 break;
626 }
627 case LS_MODIFIER_CREASE_ANGLE: {
628 LineStyleThicknessModifier_CreaseAngle *m = (LineStyleThicknessModifier_CreaseAngle *)
629 modifier;
630 BLO_read_data_address(reader, &m->curve);
631 BKE_curvemapping_blend_read(reader, m->curve);
632 break;
633 }
634 case LS_MODIFIER_CURVATURE_3D: {
635 LineStyleThicknessModifier_Curvature_3D *m = (LineStyleThicknessModifier_Curvature_3D *)
636 modifier;
637 BLO_read_data_address(reader, &m->curve);
638 BKE_curvemapping_blend_read(reader, m->curve);
639 break;
640 }
641 }
642 }
643
direct_link_linestyle_geometry_modifier(BlendDataReader * UNUSED (reader),LineStyleModifier * UNUSED (modifier))644 static void direct_link_linestyle_geometry_modifier(BlendDataReader *UNUSED(reader),
645 LineStyleModifier *UNUSED(modifier))
646 {
647 }
648
linestyle_blend_read_data(BlendDataReader * reader,ID * id)649 static void linestyle_blend_read_data(BlendDataReader *reader, ID *id)
650 {
651 FreestyleLineStyle *linestyle = (FreestyleLineStyle *)id;
652
653 BLO_read_data_address(reader, &linestyle->adt);
654 BKE_animdata_blend_read_data(reader, linestyle->adt);
655 BLO_read_list(reader, &linestyle->color_modifiers);
656 LISTBASE_FOREACH (LineStyleModifier *, modifier, &linestyle->color_modifiers) {
657 direct_link_linestyle_color_modifier(reader, modifier);
658 }
659 BLO_read_list(reader, &linestyle->alpha_modifiers);
660 LISTBASE_FOREACH (LineStyleModifier *, modifier, &linestyle->alpha_modifiers) {
661 direct_link_linestyle_alpha_modifier(reader, modifier);
662 }
663 BLO_read_list(reader, &linestyle->thickness_modifiers);
664 LISTBASE_FOREACH (LineStyleModifier *, modifier, &linestyle->thickness_modifiers) {
665 direct_link_linestyle_thickness_modifier(reader, modifier);
666 }
667 BLO_read_list(reader, &linestyle->geometry_modifiers);
668 LISTBASE_FOREACH (LineStyleModifier *, modifier, &linestyle->geometry_modifiers) {
669 direct_link_linestyle_geometry_modifier(reader, modifier);
670 }
671 for (int a = 0; a < MAX_MTEX; a++) {
672 BLO_read_data_address(reader, &linestyle->mtex[a]);
673 }
674 }
675
linestyle_blend_read_lib(BlendLibReader * reader,ID * id)676 static void linestyle_blend_read_lib(BlendLibReader *reader, ID *id)
677 {
678 FreestyleLineStyle *linestyle = (FreestyleLineStyle *)id;
679
680 LISTBASE_FOREACH (LineStyleModifier *, m, &linestyle->color_modifiers) {
681 switch (m->type) {
682 case LS_MODIFIER_DISTANCE_FROM_OBJECT: {
683 LineStyleColorModifier_DistanceFromObject *cm =
684 (LineStyleColorModifier_DistanceFromObject *)m;
685 BLO_read_id_address(reader, linestyle->id.lib, &cm->target);
686 break;
687 }
688 }
689 }
690 LISTBASE_FOREACH (LineStyleModifier *, m, &linestyle->alpha_modifiers) {
691 switch (m->type) {
692 case LS_MODIFIER_DISTANCE_FROM_OBJECT: {
693 LineStyleAlphaModifier_DistanceFromObject *am =
694 (LineStyleAlphaModifier_DistanceFromObject *)m;
695 BLO_read_id_address(reader, linestyle->id.lib, &am->target);
696 break;
697 }
698 }
699 }
700 LISTBASE_FOREACH (LineStyleModifier *, m, &linestyle->thickness_modifiers) {
701 switch (m->type) {
702 case LS_MODIFIER_DISTANCE_FROM_OBJECT: {
703 LineStyleThicknessModifier_DistanceFromObject *tm =
704 (LineStyleThicknessModifier_DistanceFromObject *)m;
705 BLO_read_id_address(reader, linestyle->id.lib, &tm->target);
706 break;
707 }
708 }
709 }
710 for (int a = 0; a < MAX_MTEX; a++) {
711 MTex *mtex = linestyle->mtex[a];
712 if (mtex) {
713 BLO_read_id_address(reader, linestyle->id.lib, &mtex->tex);
714 BLO_read_id_address(reader, linestyle->id.lib, &mtex->object);
715 }
716 }
717 }
718
linestyle_blend_read_expand(BlendExpander * expander,ID * id)719 static void linestyle_blend_read_expand(BlendExpander *expander, ID *id)
720 {
721 FreestyleLineStyle *linestyle = (FreestyleLineStyle *)id;
722
723 for (int a = 0; a < MAX_MTEX; a++) {
724 if (linestyle->mtex[a]) {
725 BLO_expand(expander, linestyle->mtex[a]->tex);
726 BLO_expand(expander, linestyle->mtex[a]->object);
727 }
728 }
729
730 LISTBASE_FOREACH (LineStyleModifier *, m, &linestyle->color_modifiers) {
731 if (m->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
732 BLO_expand(expander, ((LineStyleColorModifier_DistanceFromObject *)m)->target);
733 }
734 }
735 LISTBASE_FOREACH (LineStyleModifier *, m, &linestyle->alpha_modifiers) {
736 if (m->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
737 BLO_expand(expander, ((LineStyleAlphaModifier_DistanceFromObject *)m)->target);
738 }
739 }
740 LISTBASE_FOREACH (LineStyleModifier *, m, &linestyle->thickness_modifiers) {
741 if (m->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
742 BLO_expand(expander, ((LineStyleThicknessModifier_DistanceFromObject *)m)->target);
743 }
744 }
745 }
746
747 IDTypeInfo IDType_ID_LS = {
748 .id_code = ID_LS,
749 .id_filter = FILTER_ID_LS,
750 .main_listbase_index = INDEX_ID_LS,
751 .struct_size = sizeof(FreestyleLineStyle),
752 .name = "FreestyleLineStyle",
753 .name_plural = "linestyles",
754 .translation_context = BLT_I18NCONTEXT_ID_FREESTYLELINESTYLE,
755 .flags = 0,
756
757 .init_data = linestyle_init_data,
758 .copy_data = linestyle_copy_data,
759 .free_data = linestyle_free_data,
760 .make_local = NULL,
761 .foreach_id = linestyle_foreach_id,
762 .foreach_cache = NULL,
763
764 .blend_write = linestyle_blend_write,
765 .blend_read_data = linestyle_blend_read_data,
766 .blend_read_lib = linestyle_blend_read_lib,
767 .blend_read_expand = linestyle_blend_read_expand,
768 };
769
770 static const char *modifier_name[LS_MODIFIER_NUM] = {
771 NULL,
772 "Along Stroke",
773 "Distance from Camera",
774 "Distance from Object",
775 "Material",
776 "Sampling",
777 "Bezier Curve",
778 "Sinus Displacement",
779 "Spatial Noise",
780 "Perlin Noise 1D",
781 "Perlin Noise 2D",
782 "Backbone Stretcher",
783 "Tip Remover",
784 "Calligraphy",
785 "Polygonalization",
786 "Guiding Lines",
787 "Blueprint",
788 "2D Offset",
789 "2D Transform",
790 "Tangent",
791 "Noise",
792 "Crease Angle",
793 "Simplification",
794 "3D Curvature",
795 };
796
BKE_linestyle_init(FreestyleLineStyle * linestyle)797 void BKE_linestyle_init(FreestyleLineStyle *linestyle)
798 {
799 linestyle_init_data(&linestyle->id);
800 }
801
BKE_linestyle_new(struct Main * bmain,const char * name)802 FreestyleLineStyle *BKE_linestyle_new(struct Main *bmain, const char *name)
803 {
804 FreestyleLineStyle *linestyle;
805
806 linestyle = (FreestyleLineStyle *)BKE_libblock_alloc(bmain, ID_LS, name, 0);
807
808 BKE_linestyle_init(linestyle);
809
810 return linestyle;
811 }
812
BKE_linestyle_active_from_view_layer(ViewLayer * view_layer)813 FreestyleLineStyle *BKE_linestyle_active_from_view_layer(ViewLayer *view_layer)
814 {
815 FreestyleConfig *config = &view_layer->freestyle_config;
816 FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(config);
817 return (lineset) ? lineset->linestyle : NULL;
818 }
819
new_modifier(const char * name,int type,size_t size)820 static LineStyleModifier *new_modifier(const char *name, int type, size_t size)
821 {
822 LineStyleModifier *m;
823
824 if (!name) {
825 name = modifier_name[type];
826 }
827 m = (LineStyleModifier *)MEM_callocN(size, "line style modifier");
828 m->type = type;
829 BLI_strncpy(m->name, name, sizeof(m->name));
830 m->influence = 1.0f;
831 m->flags = LS_MODIFIER_ENABLED | LS_MODIFIER_EXPANDED;
832
833 return m;
834 }
835
add_to_modifier_list(ListBase * lb,LineStyleModifier * m)836 static void add_to_modifier_list(ListBase *lb, LineStyleModifier *m)
837 {
838 BLI_addtail(lb, (void *)m);
839 BLI_uniquename(
840 lb, m, modifier_name[m->type], '.', offsetof(LineStyleModifier, name), sizeof(m->name));
841 }
842
alloc_color_modifier(const char * name,int type)843 static LineStyleModifier *alloc_color_modifier(const char *name, int type)
844 {
845 size_t size;
846
847 switch (type) {
848 case LS_MODIFIER_ALONG_STROKE:
849 size = sizeof(LineStyleColorModifier_AlongStroke);
850 break;
851 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
852 size = sizeof(LineStyleColorModifier_DistanceFromCamera);
853 break;
854 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
855 size = sizeof(LineStyleColorModifier_DistanceFromObject);
856 break;
857 case LS_MODIFIER_MATERIAL:
858 size = sizeof(LineStyleColorModifier_Material);
859 break;
860 case LS_MODIFIER_TANGENT:
861 size = sizeof(LineStyleColorModifier_Tangent);
862 break;
863 case LS_MODIFIER_NOISE:
864 size = sizeof(LineStyleColorModifier_Noise);
865 break;
866 case LS_MODIFIER_CREASE_ANGLE:
867 size = sizeof(LineStyleColorModifier_CreaseAngle);
868 break;
869 case LS_MODIFIER_CURVATURE_3D:
870 size = sizeof(LineStyleColorModifier_Curvature_3D);
871 break;
872 default:
873 return NULL; /* unknown modifier type */
874 }
875
876 return new_modifier(name, type, size);
877 }
878
BKE_linestyle_color_modifier_add(FreestyleLineStyle * linestyle,const char * name,int type)879 LineStyleModifier *BKE_linestyle_color_modifier_add(FreestyleLineStyle *linestyle,
880 const char *name,
881 int type)
882 {
883 LineStyleModifier *m;
884
885 m = alloc_color_modifier(name, type);
886 if (UNLIKELY(m == NULL)) {
887 return NULL;
888 }
889 m->blend = MA_RAMP_BLEND;
890
891 switch (type) {
892 case LS_MODIFIER_ALONG_STROKE:
893 ((LineStyleColorModifier_AlongStroke *)m)->color_ramp = BKE_colorband_add(true);
894 break;
895 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
896 ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp = BKE_colorband_add(true);
897 ((LineStyleColorModifier_DistanceFromCamera *)m)->range_min = 0.0f;
898 ((LineStyleColorModifier_DistanceFromCamera *)m)->range_max = 10000.0f;
899 break;
900 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
901 ((LineStyleColorModifier_DistanceFromObject *)m)->target = NULL;
902 ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp = BKE_colorband_add(true);
903 ((LineStyleColorModifier_DistanceFromObject *)m)->range_min = 0.0f;
904 ((LineStyleColorModifier_DistanceFromObject *)m)->range_max = 10000.0f;
905 break;
906 case LS_MODIFIER_MATERIAL:
907 ((LineStyleColorModifier_Material *)m)->color_ramp = BKE_colorband_add(true);
908 ((LineStyleColorModifier_Material *)m)->mat_attr = LS_MODIFIER_MATERIAL_LINE;
909 break;
910 case LS_MODIFIER_TANGENT:
911 ((LineStyleColorModifier_Tangent *)m)->color_ramp = BKE_colorband_add(true);
912 break;
913 case LS_MODIFIER_NOISE:
914 ((LineStyleColorModifier_Noise *)m)->color_ramp = BKE_colorband_add(true);
915 ((LineStyleColorModifier_Noise *)m)->amplitude = 10.0f;
916 ((LineStyleColorModifier_Noise *)m)->period = 10.0f;
917 ((LineStyleColorModifier_Noise *)m)->seed = 512;
918 break;
919 case LS_MODIFIER_CREASE_ANGLE:
920 ((LineStyleColorModifier_CreaseAngle *)m)->color_ramp = BKE_colorband_add(true);
921 ((LineStyleColorModifier_CreaseAngle *)m)->min_angle = 0.0f;
922 ((LineStyleColorModifier_CreaseAngle *)m)->max_angle = DEG2RADF(180.0f);
923 break;
924 case LS_MODIFIER_CURVATURE_3D:
925 ((LineStyleColorModifier_Curvature_3D *)m)->color_ramp = BKE_colorband_add(true);
926 ((LineStyleColorModifier_Curvature_3D *)m)->min_curvature = 0.0f;
927 ((LineStyleColorModifier_Curvature_3D *)m)->max_curvature = 0.5f;
928 break;
929 default:
930 return NULL; /* unknown modifier type */
931 }
932 add_to_modifier_list(&linestyle->color_modifiers, m);
933
934 return m;
935 }
936
BKE_linestyle_color_modifier_copy(FreestyleLineStyle * linestyle,const LineStyleModifier * m,const int flag)937 LineStyleModifier *BKE_linestyle_color_modifier_copy(FreestyleLineStyle *linestyle,
938 const LineStyleModifier *m,
939 const int flag)
940 {
941 LineStyleModifier *new_m;
942
943 new_m = alloc_color_modifier(m->name, m->type);
944 if (UNLIKELY(new_m == NULL)) {
945 return NULL;
946 }
947 new_m->influence = m->influence;
948 new_m->flags = m->flags;
949 new_m->blend = m->blend;
950
951 switch (m->type) {
952 case LS_MODIFIER_ALONG_STROKE: {
953 LineStyleColorModifier_AlongStroke *p = (LineStyleColorModifier_AlongStroke *)m;
954 LineStyleColorModifier_AlongStroke *q = (LineStyleColorModifier_AlongStroke *)new_m;
955 q->color_ramp = MEM_dupallocN(p->color_ramp);
956 break;
957 }
958 case LS_MODIFIER_DISTANCE_FROM_CAMERA: {
959 LineStyleColorModifier_DistanceFromCamera *p = (LineStyleColorModifier_DistanceFromCamera *)
960 m;
961 LineStyleColorModifier_DistanceFromCamera *q = (LineStyleColorModifier_DistanceFromCamera *)
962 new_m;
963 q->color_ramp = MEM_dupallocN(p->color_ramp);
964 q->range_min = p->range_min;
965 q->range_max = p->range_max;
966 break;
967 }
968 case LS_MODIFIER_DISTANCE_FROM_OBJECT: {
969 LineStyleColorModifier_DistanceFromObject *p = (LineStyleColorModifier_DistanceFromObject *)
970 m;
971 LineStyleColorModifier_DistanceFromObject *q = (LineStyleColorModifier_DistanceFromObject *)
972 new_m;
973 q->target = p->target;
974 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
975 id_us_plus((ID *)q->target);
976 }
977 q->color_ramp = MEM_dupallocN(p->color_ramp);
978 q->range_min = p->range_min;
979 q->range_max = p->range_max;
980 break;
981 }
982 case LS_MODIFIER_MATERIAL: {
983 LineStyleColorModifier_Material *p = (LineStyleColorModifier_Material *)m;
984 LineStyleColorModifier_Material *q = (LineStyleColorModifier_Material *)new_m;
985 q->color_ramp = MEM_dupallocN(p->color_ramp);
986 q->flags = p->flags;
987 q->mat_attr = p->mat_attr;
988 break;
989 }
990 case LS_MODIFIER_TANGENT: {
991 LineStyleColorModifier_Tangent *p = (LineStyleColorModifier_Tangent *)m;
992 LineStyleColorModifier_Tangent *q = (LineStyleColorModifier_Tangent *)new_m;
993 q->color_ramp = MEM_dupallocN(p->color_ramp);
994 break;
995 }
996 case LS_MODIFIER_NOISE: {
997 LineStyleColorModifier_Noise *p = (LineStyleColorModifier_Noise *)m;
998 LineStyleColorModifier_Noise *q = (LineStyleColorModifier_Noise *)new_m;
999 q->color_ramp = MEM_dupallocN(p->color_ramp);
1000 q->amplitude = p->amplitude;
1001 q->period = p->period;
1002 q->seed = p->seed;
1003 break;
1004 }
1005 case LS_MODIFIER_CREASE_ANGLE: {
1006 LineStyleColorModifier_CreaseAngle *p = (LineStyleColorModifier_CreaseAngle *)m;
1007 LineStyleColorModifier_CreaseAngle *q = (LineStyleColorModifier_CreaseAngle *)new_m;
1008 q->color_ramp = MEM_dupallocN(p->color_ramp);
1009 q->min_angle = p->min_angle;
1010 q->max_angle = p->max_angle;
1011 break;
1012 }
1013 case LS_MODIFIER_CURVATURE_3D: {
1014 LineStyleColorModifier_Curvature_3D *p = (LineStyleColorModifier_Curvature_3D *)m;
1015 LineStyleColorModifier_Curvature_3D *q = (LineStyleColorModifier_Curvature_3D *)new_m;
1016 q->color_ramp = MEM_dupallocN(p->color_ramp);
1017 q->min_curvature = p->min_curvature;
1018 q->max_curvature = p->max_curvature;
1019 break;
1020 }
1021 default:
1022 return NULL; /* unknown modifier type */
1023 }
1024 add_to_modifier_list(&linestyle->color_modifiers, new_m);
1025
1026 return new_m;
1027 }
1028
BKE_linestyle_color_modifier_remove(FreestyleLineStyle * linestyle,LineStyleModifier * m)1029 int BKE_linestyle_color_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *m)
1030 {
1031 if (BLI_findindex(&linestyle->color_modifiers, m) == -1) {
1032 return -1;
1033 }
1034 switch (m->type) {
1035 case LS_MODIFIER_ALONG_STROKE:
1036 MEM_freeN(((LineStyleColorModifier_AlongStroke *)m)->color_ramp);
1037 break;
1038 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
1039 MEM_freeN(((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp);
1040 break;
1041 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
1042 MEM_freeN(((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp);
1043 break;
1044 case LS_MODIFIER_MATERIAL:
1045 MEM_freeN(((LineStyleColorModifier_Material *)m)->color_ramp);
1046 break;
1047 case LS_MODIFIER_TANGENT:
1048 MEM_freeN(((LineStyleColorModifier_Tangent *)m)->color_ramp);
1049 break;
1050 case LS_MODIFIER_NOISE:
1051 MEM_freeN(((LineStyleColorModifier_Noise *)m)->color_ramp);
1052 break;
1053 case LS_MODIFIER_CREASE_ANGLE:
1054 MEM_freeN(((LineStyleColorModifier_CreaseAngle *)m)->color_ramp);
1055 break;
1056 case LS_MODIFIER_CURVATURE_3D:
1057 MEM_freeN(((LineStyleColorModifier_Curvature_3D *)m)->color_ramp);
1058 break;
1059 }
1060 BLI_freelinkN(&linestyle->color_modifiers, m);
1061 return 0;
1062 }
1063
alloc_alpha_modifier(const char * name,int type)1064 static LineStyleModifier *alloc_alpha_modifier(const char *name, int type)
1065 {
1066 size_t size;
1067
1068 switch (type) {
1069 case LS_MODIFIER_ALONG_STROKE:
1070 size = sizeof(LineStyleAlphaModifier_AlongStroke);
1071 break;
1072 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
1073 size = sizeof(LineStyleAlphaModifier_DistanceFromCamera);
1074 break;
1075 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
1076 size = sizeof(LineStyleAlphaModifier_DistanceFromObject);
1077 break;
1078 case LS_MODIFIER_MATERIAL:
1079 size = sizeof(LineStyleAlphaModifier_Material);
1080 break;
1081 case LS_MODIFIER_TANGENT:
1082 size = sizeof(LineStyleAlphaModifier_Tangent);
1083 break;
1084 case LS_MODIFIER_NOISE:
1085 size = sizeof(LineStyleAlphaModifier_Noise);
1086 break;
1087 case LS_MODIFIER_CREASE_ANGLE:
1088 size = sizeof(LineStyleAlphaModifier_CreaseAngle);
1089 break;
1090 case LS_MODIFIER_CURVATURE_3D:
1091 size = sizeof(LineStyleAlphaModifier_Curvature_3D);
1092 break;
1093 default:
1094 return NULL; /* unknown modifier type */
1095 }
1096 return new_modifier(name, type, size);
1097 }
1098
BKE_linestyle_alpha_modifier_add(FreestyleLineStyle * linestyle,const char * name,int type)1099 LineStyleModifier *BKE_linestyle_alpha_modifier_add(FreestyleLineStyle *linestyle,
1100 const char *name,
1101 int type)
1102 {
1103 LineStyleModifier *m;
1104
1105 m = alloc_alpha_modifier(name, type);
1106 m->blend = LS_VALUE_BLEND;
1107
1108 switch (type) {
1109 case LS_MODIFIER_ALONG_STROKE: {
1110 LineStyleAlphaModifier_AlongStroke *p = (LineStyleAlphaModifier_AlongStroke *)m;
1111 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1112 break;
1113 }
1114 case LS_MODIFIER_DISTANCE_FROM_CAMERA: {
1115 LineStyleAlphaModifier_DistanceFromCamera *p = (LineStyleAlphaModifier_DistanceFromCamera *)
1116 m;
1117 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1118 p->range_min = 0.0f;
1119 p->range_max = 10000.0f;
1120 break;
1121 }
1122 case LS_MODIFIER_DISTANCE_FROM_OBJECT: {
1123 LineStyleAlphaModifier_DistanceFromObject *p = (LineStyleAlphaModifier_DistanceFromObject *)
1124 m;
1125 p->target = NULL;
1126 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1127 p->range_min = 0.0f;
1128 p->range_max = 10000.0f;
1129 break;
1130 }
1131 case LS_MODIFIER_MATERIAL: {
1132 LineStyleAlphaModifier_Material *p = (LineStyleAlphaModifier_Material *)m;
1133 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1134 p->mat_attr = LS_MODIFIER_MATERIAL_LINE_A;
1135 break;
1136 }
1137 case LS_MODIFIER_TANGENT: {
1138 LineStyleAlphaModifier_Tangent *p = (LineStyleAlphaModifier_Tangent *)m;
1139 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1140 break;
1141 }
1142 case LS_MODIFIER_NOISE: {
1143 LineStyleAlphaModifier_Noise *p = (LineStyleAlphaModifier_Noise *)m;
1144 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1145 ((LineStyleAlphaModifier_Noise *)m)->amplitude = 10.0f;
1146 ((LineStyleAlphaModifier_Noise *)m)->period = 10.0f;
1147 ((LineStyleAlphaModifier_Noise *)m)->seed = 512;
1148 break;
1149 }
1150 case LS_MODIFIER_CREASE_ANGLE: {
1151 LineStyleAlphaModifier_CreaseAngle *p = (LineStyleAlphaModifier_CreaseAngle *)m;
1152 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1153 ((LineStyleAlphaModifier_CreaseAngle *)m)->min_angle = 0.0f;
1154 ((LineStyleAlphaModifier_CreaseAngle *)m)->max_angle = DEG2RADF(180.0f);
1155 break;
1156 }
1157 case LS_MODIFIER_CURVATURE_3D: {
1158 LineStyleAlphaModifier_Curvature_3D *p = (LineStyleAlphaModifier_Curvature_3D *)m;
1159 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1160 ((LineStyleAlphaModifier_Curvature_3D *)m)->min_curvature = 0.0f;
1161 ((LineStyleAlphaModifier_Curvature_3D *)m)->max_curvature = 0.5f;
1162 break;
1163 }
1164 default:
1165 return NULL; /* unknown modifier type */
1166 }
1167 add_to_modifier_list(&linestyle->alpha_modifiers, m);
1168
1169 return m;
1170 }
1171
BKE_linestyle_alpha_modifier_copy(FreestyleLineStyle * linestyle,const LineStyleModifier * m,const int UNUSED (flag))1172 LineStyleModifier *BKE_linestyle_alpha_modifier_copy(FreestyleLineStyle *linestyle,
1173 const LineStyleModifier *m,
1174 const int UNUSED(flag))
1175 {
1176 LineStyleModifier *new_m;
1177
1178 new_m = alloc_alpha_modifier(m->name, m->type);
1179 new_m->influence = m->influence;
1180 new_m->flags = m->flags;
1181 new_m->blend = m->blend;
1182
1183 switch (m->type) {
1184 case LS_MODIFIER_ALONG_STROKE: {
1185 LineStyleAlphaModifier_AlongStroke *p = (LineStyleAlphaModifier_AlongStroke *)m;
1186 LineStyleAlphaModifier_AlongStroke *q = (LineStyleAlphaModifier_AlongStroke *)new_m;
1187 q->curve = BKE_curvemapping_copy(p->curve);
1188 q->flags = p->flags;
1189 break;
1190 }
1191 case LS_MODIFIER_DISTANCE_FROM_CAMERA: {
1192 LineStyleAlphaModifier_DistanceFromCamera *p = (LineStyleAlphaModifier_DistanceFromCamera *)
1193 m;
1194 LineStyleAlphaModifier_DistanceFromCamera *q = (LineStyleAlphaModifier_DistanceFromCamera *)
1195 new_m;
1196 q->curve = BKE_curvemapping_copy(p->curve);
1197 q->flags = p->flags;
1198 q->range_min = p->range_min;
1199 q->range_max = p->range_max;
1200 break;
1201 }
1202 case LS_MODIFIER_DISTANCE_FROM_OBJECT: {
1203 LineStyleAlphaModifier_DistanceFromObject *p = (LineStyleAlphaModifier_DistanceFromObject *)
1204 m;
1205 LineStyleAlphaModifier_DistanceFromObject *q = (LineStyleAlphaModifier_DistanceFromObject *)
1206 new_m;
1207 if (p->target) {
1208 id_us_plus(&p->target->id);
1209 }
1210 q->target = p->target;
1211 q->curve = BKE_curvemapping_copy(p->curve);
1212 q->flags = p->flags;
1213 q->range_min = p->range_min;
1214 q->range_max = p->range_max;
1215 break;
1216 }
1217 case LS_MODIFIER_MATERIAL: {
1218 LineStyleAlphaModifier_Material *p = (LineStyleAlphaModifier_Material *)m;
1219 LineStyleAlphaModifier_Material *q = (LineStyleAlphaModifier_Material *)new_m;
1220 q->curve = BKE_curvemapping_copy(p->curve);
1221 q->flags = p->flags;
1222 q->mat_attr = p->mat_attr;
1223 break;
1224 }
1225 case LS_MODIFIER_TANGENT: {
1226 LineStyleAlphaModifier_Tangent *p = (LineStyleAlphaModifier_Tangent *)m;
1227 LineStyleAlphaModifier_Tangent *q = (LineStyleAlphaModifier_Tangent *)new_m;
1228 q->curve = BKE_curvemapping_copy(p->curve);
1229 q->flags = p->flags;
1230 break;
1231 }
1232 case LS_MODIFIER_NOISE: {
1233 LineStyleAlphaModifier_Noise *p = (LineStyleAlphaModifier_Noise *)m;
1234 LineStyleAlphaModifier_Noise *q = (LineStyleAlphaModifier_Noise *)new_m;
1235 q->curve = BKE_curvemapping_copy(p->curve);
1236 q->flags = p->flags;
1237 q->amplitude = p->amplitude;
1238 q->period = p->period;
1239 q->seed = p->seed;
1240 break;
1241 }
1242 case LS_MODIFIER_CREASE_ANGLE: {
1243 LineStyleAlphaModifier_CreaseAngle *p = (LineStyleAlphaModifier_CreaseAngle *)m;
1244 LineStyleAlphaModifier_CreaseAngle *q = (LineStyleAlphaModifier_CreaseAngle *)new_m;
1245 q->curve = BKE_curvemapping_copy(p->curve);
1246 q->flags = p->flags;
1247 q->min_angle = p->min_angle;
1248 q->max_angle = p->max_angle;
1249 break;
1250 }
1251 case LS_MODIFIER_CURVATURE_3D: {
1252 LineStyleAlphaModifier_Curvature_3D *p = (LineStyleAlphaModifier_Curvature_3D *)m;
1253 LineStyleAlphaModifier_Curvature_3D *q = (LineStyleAlphaModifier_Curvature_3D *)new_m;
1254 q->curve = BKE_curvemapping_copy(p->curve);
1255 q->flags = p->flags;
1256 q->min_curvature = p->min_curvature;
1257 q->max_curvature = p->max_curvature;
1258 break;
1259 }
1260 default:
1261 return NULL; /* unknown modifier type */
1262 }
1263 add_to_modifier_list(&linestyle->alpha_modifiers, new_m);
1264
1265 return new_m;
1266 }
1267
BKE_linestyle_alpha_modifier_remove(FreestyleLineStyle * linestyle,LineStyleModifier * m)1268 int BKE_linestyle_alpha_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *m)
1269 {
1270 if (BLI_findindex(&linestyle->alpha_modifiers, m) == -1) {
1271 return -1;
1272 }
1273 switch (m->type) {
1274 case LS_MODIFIER_ALONG_STROKE:
1275 BKE_curvemapping_free(((LineStyleAlphaModifier_AlongStroke *)m)->curve);
1276 break;
1277 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
1278 BKE_curvemapping_free(((LineStyleAlphaModifier_DistanceFromCamera *)m)->curve);
1279 break;
1280 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
1281 BKE_curvemapping_free(((LineStyleAlphaModifier_DistanceFromObject *)m)->curve);
1282 break;
1283 case LS_MODIFIER_MATERIAL:
1284 BKE_curvemapping_free(((LineStyleAlphaModifier_Material *)m)->curve);
1285 break;
1286 case LS_MODIFIER_TANGENT:
1287 BKE_curvemapping_free(((LineStyleAlphaModifier_Tangent *)m)->curve);
1288 break;
1289 case LS_MODIFIER_NOISE:
1290 BKE_curvemapping_free(((LineStyleAlphaModifier_Noise *)m)->curve);
1291 break;
1292 case LS_MODIFIER_CREASE_ANGLE:
1293 BKE_curvemapping_free(((LineStyleAlphaModifier_CreaseAngle *)m)->curve);
1294 break;
1295 case LS_MODIFIER_CURVATURE_3D:
1296 BKE_curvemapping_free(((LineStyleAlphaModifier_Curvature_3D *)m)->curve);
1297 break;
1298 }
1299 BLI_freelinkN(&linestyle->alpha_modifiers, m);
1300 return 0;
1301 }
1302
alloc_thickness_modifier(const char * name,int type)1303 static LineStyleModifier *alloc_thickness_modifier(const char *name, int type)
1304 {
1305 size_t size;
1306
1307 switch (type) {
1308 case LS_MODIFIER_ALONG_STROKE:
1309 size = sizeof(LineStyleThicknessModifier_AlongStroke);
1310 break;
1311 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
1312 size = sizeof(LineStyleThicknessModifier_DistanceFromCamera);
1313 break;
1314 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
1315 size = sizeof(LineStyleThicknessModifier_DistanceFromObject);
1316 break;
1317 case LS_MODIFIER_MATERIAL:
1318 size = sizeof(LineStyleThicknessModifier_Material);
1319 break;
1320 case LS_MODIFIER_CALLIGRAPHY:
1321 size = sizeof(LineStyleThicknessModifier_Calligraphy);
1322 break;
1323 case LS_MODIFIER_TANGENT:
1324 size = sizeof(LineStyleThicknessModifier_Tangent);
1325 break;
1326 case LS_MODIFIER_NOISE:
1327 size = sizeof(LineStyleThicknessModifier_Noise);
1328 break;
1329 case LS_MODIFIER_CREASE_ANGLE:
1330 size = sizeof(LineStyleThicknessModifier_CreaseAngle);
1331 break;
1332 case LS_MODIFIER_CURVATURE_3D:
1333 size = sizeof(LineStyleThicknessModifier_Curvature_3D);
1334 break;
1335 default:
1336 return NULL; /* unknown modifier type */
1337 }
1338
1339 return new_modifier(name, type, size);
1340 }
1341
BKE_linestyle_thickness_modifier_add(FreestyleLineStyle * linestyle,const char * name,int type)1342 LineStyleModifier *BKE_linestyle_thickness_modifier_add(FreestyleLineStyle *linestyle,
1343 const char *name,
1344 int type)
1345 {
1346 LineStyleModifier *m;
1347
1348 m = alloc_thickness_modifier(name, type);
1349 m->blend = LS_VALUE_BLEND;
1350
1351 switch (type) {
1352 case LS_MODIFIER_ALONG_STROKE: {
1353 LineStyleThicknessModifier_AlongStroke *p = (LineStyleThicknessModifier_AlongStroke *)m;
1354 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1355 p->value_min = 0.0f;
1356 p->value_max = 1.0f;
1357 break;
1358 }
1359 case LS_MODIFIER_DISTANCE_FROM_CAMERA: {
1360 LineStyleThicknessModifier_DistanceFromCamera *p =
1361 (LineStyleThicknessModifier_DistanceFromCamera *)m;
1362 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1363 p->range_min = 0.0f;
1364 p->range_max = 1000.0f;
1365 p->value_min = 0.0f;
1366 p->value_max = 1.0f;
1367 break;
1368 }
1369 case LS_MODIFIER_DISTANCE_FROM_OBJECT: {
1370 LineStyleThicknessModifier_DistanceFromObject *p =
1371 (LineStyleThicknessModifier_DistanceFromObject *)m;
1372 p->target = NULL;
1373 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1374 p->range_min = 0.0f;
1375 p->range_max = 1000.0f;
1376 p->value_min = 0.0f;
1377 p->value_max = 1.0f;
1378 break;
1379 }
1380 case LS_MODIFIER_MATERIAL: {
1381 LineStyleThicknessModifier_Material *p = (LineStyleThicknessModifier_Material *)m;
1382 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1383 p->mat_attr = LS_MODIFIER_MATERIAL_LINE;
1384 p->value_min = 0.0f;
1385 p->value_max = 1.0f;
1386 break;
1387 }
1388 case LS_MODIFIER_CALLIGRAPHY: {
1389 LineStyleThicknessModifier_Calligraphy *p = (LineStyleThicknessModifier_Calligraphy *)m;
1390 p->min_thickness = 1.0f;
1391 p->max_thickness = 10.0f;
1392 p->orientation = DEG2RADF(60.0f);
1393 break;
1394 }
1395 case LS_MODIFIER_TANGENT: {
1396 LineStyleThicknessModifier_Tangent *p = (LineStyleThicknessModifier_Tangent *)m;
1397 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1398 p->min_thickness = 1.0f;
1399 p->max_thickness = 10.0f;
1400 break;
1401 }
1402 case LS_MODIFIER_NOISE: {
1403 LineStyleThicknessModifier_Noise *p = (LineStyleThicknessModifier_Noise *)m;
1404 p->period = 10.0f;
1405 p->amplitude = 10.0f;
1406 p->seed = 512;
1407 p->flags = LS_THICKNESS_ASYMMETRIC;
1408 break;
1409 }
1410 case LS_MODIFIER_CREASE_ANGLE: {
1411 LineStyleThicknessModifier_CreaseAngle *p = (LineStyleThicknessModifier_CreaseAngle *)m;
1412 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1413 p->min_angle = 0.0f;
1414 p->max_angle = DEG2RADF(180.0f);
1415 p->min_thickness = 1.0f;
1416 p->max_thickness = 10.0f;
1417 break;
1418 }
1419 case LS_MODIFIER_CURVATURE_3D: {
1420 LineStyleThicknessModifier_Curvature_3D *p = (LineStyleThicknessModifier_Curvature_3D *)m;
1421 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1422 p->min_curvature = 0.0f;
1423 p->max_curvature = 0.5f;
1424 p->min_thickness = 1.0f;
1425 p->max_thickness = 10.0f;
1426 break;
1427 }
1428 default:
1429 return NULL; /* unknown modifier type */
1430 }
1431 add_to_modifier_list(&linestyle->thickness_modifiers, m);
1432
1433 return m;
1434 }
1435
BKE_linestyle_thickness_modifier_copy(FreestyleLineStyle * linestyle,const LineStyleModifier * m,const int flag)1436 LineStyleModifier *BKE_linestyle_thickness_modifier_copy(FreestyleLineStyle *linestyle,
1437 const LineStyleModifier *m,
1438 const int flag)
1439 {
1440 LineStyleModifier *new_m;
1441
1442 new_m = alloc_thickness_modifier(m->name, m->type);
1443 if (!new_m) {
1444 return NULL;
1445 }
1446 new_m->influence = m->influence;
1447 new_m->flags = m->flags;
1448 new_m->blend = m->blend;
1449
1450 switch (m->type) {
1451 case LS_MODIFIER_ALONG_STROKE: {
1452 LineStyleThicknessModifier_AlongStroke *p = (LineStyleThicknessModifier_AlongStroke *)m;
1453 LineStyleThicknessModifier_AlongStroke *q = (LineStyleThicknessModifier_AlongStroke *)new_m;
1454 q->curve = BKE_curvemapping_copy(p->curve);
1455 q->flags = p->flags;
1456 q->value_min = p->value_min;
1457 q->value_max = p->value_max;
1458 break;
1459 }
1460 case LS_MODIFIER_DISTANCE_FROM_CAMERA: {
1461 LineStyleThicknessModifier_DistanceFromCamera *p =
1462 (LineStyleThicknessModifier_DistanceFromCamera *)m;
1463 LineStyleThicknessModifier_DistanceFromCamera *q =
1464 (LineStyleThicknessModifier_DistanceFromCamera *)new_m;
1465 q->curve = BKE_curvemapping_copy(p->curve);
1466 q->flags = p->flags;
1467 q->range_min = p->range_min;
1468 q->range_max = p->range_max;
1469 q->value_min = p->value_min;
1470 q->value_max = p->value_max;
1471 break;
1472 }
1473 case LS_MODIFIER_DISTANCE_FROM_OBJECT: {
1474 LineStyleThicknessModifier_DistanceFromObject *p =
1475 (LineStyleThicknessModifier_DistanceFromObject *)m;
1476 LineStyleThicknessModifier_DistanceFromObject *q =
1477 (LineStyleThicknessModifier_DistanceFromObject *)new_m;
1478 q->target = p->target;
1479 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
1480 id_us_plus((ID *)q->target);
1481 }
1482 q->curve = BKE_curvemapping_copy(p->curve);
1483 q->flags = p->flags;
1484 q->range_min = p->range_min;
1485 q->range_max = p->range_max;
1486 q->value_min = p->value_min;
1487 q->value_max = p->value_max;
1488 break;
1489 }
1490 case LS_MODIFIER_MATERIAL: {
1491 LineStyleThicknessModifier_Material *p = (LineStyleThicknessModifier_Material *)m;
1492 LineStyleThicknessModifier_Material *q = (LineStyleThicknessModifier_Material *)new_m;
1493 q->curve = BKE_curvemapping_copy(p->curve);
1494 q->flags = p->flags;
1495 q->mat_attr = p->mat_attr;
1496 q->value_min = p->value_min;
1497 q->value_max = p->value_max;
1498 break;
1499 }
1500 case LS_MODIFIER_CALLIGRAPHY: {
1501 LineStyleThicknessModifier_Calligraphy *p = (LineStyleThicknessModifier_Calligraphy *)m;
1502 LineStyleThicknessModifier_Calligraphy *q = (LineStyleThicknessModifier_Calligraphy *)new_m;
1503 q->min_thickness = p->min_thickness;
1504 q->max_thickness = p->max_thickness;
1505 q->orientation = p->orientation;
1506 break;
1507 }
1508 case LS_MODIFIER_TANGENT: {
1509 LineStyleThicknessModifier_Tangent *p = (LineStyleThicknessModifier_Tangent *)m;
1510 LineStyleThicknessModifier_Tangent *q = (LineStyleThicknessModifier_Tangent *)new_m;
1511 q->curve = BKE_curvemapping_copy(p->curve);
1512 q->flags = p->flags;
1513 q->min_thickness = p->min_thickness;
1514 q->max_thickness = p->max_thickness;
1515 break;
1516 }
1517 case LS_MODIFIER_NOISE: {
1518 LineStyleThicknessModifier_Noise *p = (LineStyleThicknessModifier_Noise *)m;
1519 LineStyleThicknessModifier_Noise *q = (LineStyleThicknessModifier_Noise *)new_m;
1520 q->amplitude = p->amplitude;
1521 q->period = p->period;
1522 q->seed = p->seed;
1523 q->flags = p->flags;
1524 break;
1525 }
1526 case LS_MODIFIER_CURVATURE_3D: {
1527 LineStyleThicknessModifier_Curvature_3D *p = (LineStyleThicknessModifier_Curvature_3D *)m;
1528 LineStyleThicknessModifier_Curvature_3D *q = (LineStyleThicknessModifier_Curvature_3D *)
1529 new_m;
1530 q->curve = BKE_curvemapping_copy(p->curve);
1531 q->flags = p->flags;
1532 q->min_curvature = p->min_curvature;
1533 q->max_curvature = p->max_curvature;
1534 q->min_thickness = p->min_thickness;
1535 q->max_thickness = p->max_thickness;
1536 break;
1537 }
1538 case LS_MODIFIER_CREASE_ANGLE: {
1539 LineStyleThicknessModifier_CreaseAngle *p = (LineStyleThicknessModifier_CreaseAngle *)m;
1540 LineStyleThicknessModifier_CreaseAngle *q = (LineStyleThicknessModifier_CreaseAngle *)new_m;
1541 q->curve = BKE_curvemapping_copy(p->curve);
1542 q->flags = p->flags;
1543 q->min_angle = p->min_angle;
1544 q->max_angle = p->max_angle;
1545 q->min_thickness = p->min_thickness;
1546 q->max_thickness = p->max_thickness;
1547 break;
1548 }
1549 default:
1550 return NULL; /* unknown modifier type */
1551 }
1552 add_to_modifier_list(&linestyle->thickness_modifiers, new_m);
1553
1554 return new_m;
1555 }
1556
BKE_linestyle_thickness_modifier_remove(FreestyleLineStyle * linestyle,LineStyleModifier * m)1557 int BKE_linestyle_thickness_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *m)
1558 {
1559 if (BLI_findindex(&linestyle->thickness_modifiers, m) == -1) {
1560 return -1;
1561 }
1562 switch (m->type) {
1563 case LS_MODIFIER_ALONG_STROKE:
1564 BKE_curvemapping_free(((LineStyleThicknessModifier_AlongStroke *)m)->curve);
1565 break;
1566 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
1567 BKE_curvemapping_free(((LineStyleThicknessModifier_DistanceFromCamera *)m)->curve);
1568 break;
1569 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
1570 BKE_curvemapping_free(((LineStyleThicknessModifier_DistanceFromObject *)m)->curve);
1571 break;
1572 case LS_MODIFIER_MATERIAL:
1573 BKE_curvemapping_free(((LineStyleThicknessModifier_Material *)m)->curve);
1574 break;
1575 case LS_MODIFIER_CALLIGRAPHY:
1576 break;
1577 case LS_MODIFIER_TANGENT:
1578 BKE_curvemapping_free(((LineStyleThicknessModifier_Tangent *)m)->curve);
1579 break;
1580 case LS_MODIFIER_NOISE:
1581 break;
1582 case LS_MODIFIER_CREASE_ANGLE:
1583 break;
1584 case LS_MODIFIER_CURVATURE_3D:
1585 break;
1586 }
1587 BLI_freelinkN(&linestyle->thickness_modifiers, m);
1588 return 0;
1589 }
1590
alloc_geometry_modifier(const char * name,int type)1591 static LineStyleModifier *alloc_geometry_modifier(const char *name, int type)
1592 {
1593 size_t size;
1594
1595 switch (type) {
1596 case LS_MODIFIER_SAMPLING:
1597 size = sizeof(LineStyleGeometryModifier_Sampling);
1598 break;
1599 case LS_MODIFIER_BEZIER_CURVE:
1600 size = sizeof(LineStyleGeometryModifier_BezierCurve);
1601 break;
1602 case LS_MODIFIER_SINUS_DISPLACEMENT:
1603 size = sizeof(LineStyleGeometryModifier_SinusDisplacement);
1604 break;
1605 case LS_MODIFIER_SPATIAL_NOISE:
1606 size = sizeof(LineStyleGeometryModifier_SpatialNoise);
1607 break;
1608 case LS_MODIFIER_PERLIN_NOISE_1D:
1609 size = sizeof(LineStyleGeometryModifier_PerlinNoise1D);
1610 break;
1611 case LS_MODIFIER_PERLIN_NOISE_2D:
1612 size = sizeof(LineStyleGeometryModifier_PerlinNoise2D);
1613 break;
1614 case LS_MODIFIER_BACKBONE_STRETCHER:
1615 size = sizeof(LineStyleGeometryModifier_BackboneStretcher);
1616 break;
1617 case LS_MODIFIER_TIP_REMOVER:
1618 size = sizeof(LineStyleGeometryModifier_TipRemover);
1619 break;
1620 case LS_MODIFIER_POLYGONIZATION:
1621 size = sizeof(LineStyleGeometryModifier_Polygonalization);
1622 break;
1623 case LS_MODIFIER_GUIDING_LINES:
1624 size = sizeof(LineStyleGeometryModifier_GuidingLines);
1625 break;
1626 case LS_MODIFIER_BLUEPRINT:
1627 size = sizeof(LineStyleGeometryModifier_Blueprint);
1628 break;
1629 case LS_MODIFIER_2D_OFFSET:
1630 size = sizeof(LineStyleGeometryModifier_2DOffset);
1631 break;
1632 case LS_MODIFIER_2D_TRANSFORM:
1633 size = sizeof(LineStyleGeometryModifier_2DTransform);
1634 break;
1635 case LS_MODIFIER_SIMPLIFICATION:
1636 size = sizeof(LineStyleGeometryModifier_Simplification);
1637 break;
1638 default:
1639 return NULL; /* unknown modifier type */
1640 }
1641
1642 return new_modifier(name, type, size);
1643 }
1644
BKE_linestyle_geometry_modifier_add(FreestyleLineStyle * linestyle,const char * name,int type)1645 LineStyleModifier *BKE_linestyle_geometry_modifier_add(FreestyleLineStyle *linestyle,
1646 const char *name,
1647 int type)
1648 {
1649 LineStyleModifier *m;
1650
1651 m = alloc_geometry_modifier(name, type);
1652
1653 switch (type) {
1654 case LS_MODIFIER_SAMPLING: {
1655 LineStyleGeometryModifier_Sampling *p = (LineStyleGeometryModifier_Sampling *)m;
1656 p->sampling = 10.0f;
1657 break;
1658 }
1659 case LS_MODIFIER_BEZIER_CURVE: {
1660 LineStyleGeometryModifier_BezierCurve *p = (LineStyleGeometryModifier_BezierCurve *)m;
1661 p->error = 10.0f;
1662 break;
1663 }
1664 case LS_MODIFIER_SINUS_DISPLACEMENT: {
1665 LineStyleGeometryModifier_SinusDisplacement *p =
1666 (LineStyleGeometryModifier_SinusDisplacement *)m;
1667 p->wavelength = 20.0f;
1668 p->amplitude = 5.0f;
1669 p->phase = 0.0f;
1670 break;
1671 }
1672 case LS_MODIFIER_SPATIAL_NOISE: {
1673 LineStyleGeometryModifier_SpatialNoise *p = (LineStyleGeometryModifier_SpatialNoise *)m;
1674 p->amplitude = 5.0f;
1675 p->scale = 20.0f;
1676 p->octaves = 4;
1677 p->flags = LS_MODIFIER_SPATIAL_NOISE_SMOOTH | LS_MODIFIER_SPATIAL_NOISE_PURERANDOM;
1678 break;
1679 }
1680 case LS_MODIFIER_PERLIN_NOISE_1D: {
1681 LineStyleGeometryModifier_PerlinNoise1D *p = (LineStyleGeometryModifier_PerlinNoise1D *)m;
1682 p->frequency = 10.0f;
1683 p->amplitude = 10.0f;
1684 p->octaves = 4;
1685 p->angle = DEG2RADF(45.0f);
1686 break;
1687 }
1688 case LS_MODIFIER_PERLIN_NOISE_2D: {
1689 LineStyleGeometryModifier_PerlinNoise2D *p = (LineStyleGeometryModifier_PerlinNoise2D *)m;
1690 p->frequency = 10.0f;
1691 p->amplitude = 10.0f;
1692 p->octaves = 4;
1693 p->angle = DEG2RADF(45.0f);
1694 break;
1695 }
1696 case LS_MODIFIER_BACKBONE_STRETCHER: {
1697 LineStyleGeometryModifier_BackboneStretcher *p =
1698 (LineStyleGeometryModifier_BackboneStretcher *)m;
1699 p->backbone_length = 10.0f;
1700 break;
1701 }
1702 case LS_MODIFIER_TIP_REMOVER: {
1703 LineStyleGeometryModifier_TipRemover *p = (LineStyleGeometryModifier_TipRemover *)m;
1704 p->tip_length = 10.0f;
1705 break;
1706 }
1707 case LS_MODIFIER_POLYGONIZATION: {
1708 LineStyleGeometryModifier_Polygonalization *p =
1709 (LineStyleGeometryModifier_Polygonalization *)m;
1710 p->error = 10.0f;
1711 break;
1712 }
1713 case LS_MODIFIER_GUIDING_LINES: {
1714 LineStyleGeometryModifier_GuidingLines *p = (LineStyleGeometryModifier_GuidingLines *)m;
1715 p->offset = 0.0f;
1716 break;
1717 }
1718 case LS_MODIFIER_BLUEPRINT: {
1719 LineStyleGeometryModifier_Blueprint *p = (LineStyleGeometryModifier_Blueprint *)m;
1720 p->flags = LS_MODIFIER_BLUEPRINT_CIRCLES;
1721 p->rounds = 1;
1722 p->backbone_length = 10.0f;
1723 p->random_radius = 3;
1724 p->random_center = 5;
1725 p->random_backbone = 5;
1726 break;
1727 }
1728 case LS_MODIFIER_2D_OFFSET: {
1729 LineStyleGeometryModifier_2DOffset *p = (LineStyleGeometryModifier_2DOffset *)m;
1730 p->start = 0.0f;
1731 p->end = 0.0f;
1732 p->x = 0.0f;
1733 p->y = 0.0f;
1734 break;
1735 }
1736 case LS_MODIFIER_2D_TRANSFORM: {
1737 LineStyleGeometryModifier_2DTransform *p = (LineStyleGeometryModifier_2DTransform *)m;
1738 p->pivot = LS_MODIFIER_2D_TRANSFORM_PIVOT_CENTER;
1739 p->scale_x = 1.0f;
1740 p->scale_y = 1.0f;
1741 p->angle = DEG2RADF(0.0f);
1742 p->pivot_u = 0.5f;
1743 p->pivot_x = 0.0f;
1744 p->pivot_y = 0.0f;
1745 break;
1746 }
1747 case LS_MODIFIER_SIMPLIFICATION: {
1748 LineStyleGeometryModifier_Simplification *p = (LineStyleGeometryModifier_Simplification *)m;
1749 p->tolerance = 0.1f;
1750 break;
1751 }
1752 default:
1753 return NULL; /* unknown modifier type */
1754 }
1755 add_to_modifier_list(&linestyle->geometry_modifiers, m);
1756
1757 return m;
1758 }
1759
BKE_linestyle_geometry_modifier_copy(FreestyleLineStyle * linestyle,const LineStyleModifier * m,const int UNUSED (flag))1760 LineStyleModifier *BKE_linestyle_geometry_modifier_copy(FreestyleLineStyle *linestyle,
1761 const LineStyleModifier *m,
1762 const int UNUSED(flag))
1763 {
1764 LineStyleModifier *new_m;
1765
1766 new_m = alloc_geometry_modifier(m->name, m->type);
1767 new_m->flags = m->flags;
1768
1769 switch (m->type) {
1770 case LS_MODIFIER_SAMPLING: {
1771 LineStyleGeometryModifier_Sampling *p = (LineStyleGeometryModifier_Sampling *)m;
1772 LineStyleGeometryModifier_Sampling *q = (LineStyleGeometryModifier_Sampling *)new_m;
1773 q->sampling = p->sampling;
1774 break;
1775 }
1776 case LS_MODIFIER_BEZIER_CURVE: {
1777 LineStyleGeometryModifier_BezierCurve *p = (LineStyleGeometryModifier_BezierCurve *)m;
1778 LineStyleGeometryModifier_BezierCurve *q = (LineStyleGeometryModifier_BezierCurve *)new_m;
1779 q->error = p->error;
1780 break;
1781 }
1782 case LS_MODIFIER_SINUS_DISPLACEMENT: {
1783 LineStyleGeometryModifier_SinusDisplacement *p =
1784 (LineStyleGeometryModifier_SinusDisplacement *)m;
1785 LineStyleGeometryModifier_SinusDisplacement *q =
1786 (LineStyleGeometryModifier_SinusDisplacement *)new_m;
1787 q->wavelength = p->wavelength;
1788 q->amplitude = p->amplitude;
1789 q->phase = p->phase;
1790 break;
1791 }
1792 case LS_MODIFIER_SPATIAL_NOISE: {
1793 LineStyleGeometryModifier_SpatialNoise *p = (LineStyleGeometryModifier_SpatialNoise *)m;
1794 LineStyleGeometryModifier_SpatialNoise *q = (LineStyleGeometryModifier_SpatialNoise *)new_m;
1795 q->amplitude = p->amplitude;
1796 q->scale = p->scale;
1797 q->octaves = p->octaves;
1798 q->flags = p->flags;
1799 break;
1800 }
1801 case LS_MODIFIER_PERLIN_NOISE_1D: {
1802 LineStyleGeometryModifier_PerlinNoise1D *p = (LineStyleGeometryModifier_PerlinNoise1D *)m;
1803 LineStyleGeometryModifier_PerlinNoise1D *q = (LineStyleGeometryModifier_PerlinNoise1D *)
1804 new_m;
1805 q->frequency = p->frequency;
1806 q->amplitude = p->amplitude;
1807 q->angle = p->angle;
1808 q->octaves = p->octaves;
1809 q->seed = p->seed;
1810 break;
1811 }
1812 case LS_MODIFIER_PERLIN_NOISE_2D: {
1813 LineStyleGeometryModifier_PerlinNoise2D *p = (LineStyleGeometryModifier_PerlinNoise2D *)m;
1814 LineStyleGeometryModifier_PerlinNoise2D *q = (LineStyleGeometryModifier_PerlinNoise2D *)
1815 new_m;
1816 q->frequency = p->frequency;
1817 q->amplitude = p->amplitude;
1818 q->angle = p->angle;
1819 q->octaves = p->octaves;
1820 q->seed = p->seed;
1821 break;
1822 }
1823 case LS_MODIFIER_BACKBONE_STRETCHER: {
1824 LineStyleGeometryModifier_BackboneStretcher *p =
1825 (LineStyleGeometryModifier_BackboneStretcher *)m;
1826 LineStyleGeometryModifier_BackboneStretcher *q =
1827 (LineStyleGeometryModifier_BackboneStretcher *)new_m;
1828 q->backbone_length = p->backbone_length;
1829 break;
1830 }
1831 case LS_MODIFIER_TIP_REMOVER: {
1832 LineStyleGeometryModifier_TipRemover *p = (LineStyleGeometryModifier_TipRemover *)m;
1833 LineStyleGeometryModifier_TipRemover *q = (LineStyleGeometryModifier_TipRemover *)new_m;
1834 q->tip_length = p->tip_length;
1835 break;
1836 }
1837 case LS_MODIFIER_POLYGONIZATION: {
1838 LineStyleGeometryModifier_Polygonalization *p =
1839 (LineStyleGeometryModifier_Polygonalization *)m;
1840 LineStyleGeometryModifier_Polygonalization *q =
1841 (LineStyleGeometryModifier_Polygonalization *)new_m;
1842 q->error = p->error;
1843 break;
1844 }
1845 case LS_MODIFIER_GUIDING_LINES: {
1846 LineStyleGeometryModifier_GuidingLines *p = (LineStyleGeometryModifier_GuidingLines *)m;
1847 LineStyleGeometryModifier_GuidingLines *q = (LineStyleGeometryModifier_GuidingLines *)new_m;
1848 q->offset = p->offset;
1849 break;
1850 }
1851 case LS_MODIFIER_BLUEPRINT: {
1852 LineStyleGeometryModifier_Blueprint *p = (LineStyleGeometryModifier_Blueprint *)m;
1853 LineStyleGeometryModifier_Blueprint *q = (LineStyleGeometryModifier_Blueprint *)new_m;
1854 q->flags = p->flags;
1855 q->rounds = p->rounds;
1856 q->backbone_length = p->backbone_length;
1857 q->random_radius = p->random_radius;
1858 q->random_center = p->random_center;
1859 q->random_backbone = p->random_backbone;
1860 break;
1861 }
1862 case LS_MODIFIER_2D_OFFSET: {
1863 LineStyleGeometryModifier_2DOffset *p = (LineStyleGeometryModifier_2DOffset *)m;
1864 LineStyleGeometryModifier_2DOffset *q = (LineStyleGeometryModifier_2DOffset *)new_m;
1865 q->start = p->start;
1866 q->end = p->end;
1867 q->x = p->x;
1868 q->y = p->y;
1869 break;
1870 }
1871 case LS_MODIFIER_2D_TRANSFORM: {
1872 LineStyleGeometryModifier_2DTransform *p = (LineStyleGeometryModifier_2DTransform *)m;
1873 LineStyleGeometryModifier_2DTransform *q = (LineStyleGeometryModifier_2DTransform *)new_m;
1874 q->pivot = p->pivot;
1875 q->scale_x = p->scale_x;
1876 q->scale_y = p->scale_y;
1877 q->angle = p->angle;
1878 q->pivot_u = p->pivot_u;
1879 q->pivot_x = p->pivot_x;
1880 q->pivot_y = p->pivot_y;
1881 break;
1882 }
1883 case LS_MODIFIER_SIMPLIFICATION: {
1884 LineStyleGeometryModifier_Simplification *p = (LineStyleGeometryModifier_Simplification *)m;
1885 LineStyleGeometryModifier_Simplification *q = (LineStyleGeometryModifier_Simplification *)
1886 new_m;
1887 q->tolerance = p->tolerance;
1888 break;
1889 }
1890 default:
1891 return NULL; /* unknown modifier type */
1892 }
1893 add_to_modifier_list(&linestyle->geometry_modifiers, new_m);
1894
1895 return new_m;
1896 }
1897
BKE_linestyle_geometry_modifier_remove(FreestyleLineStyle * linestyle,LineStyleModifier * m)1898 int BKE_linestyle_geometry_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *m)
1899 {
1900 if (BLI_findindex(&linestyle->geometry_modifiers, m) == -1) {
1901 return -1;
1902 }
1903 BLI_freelinkN(&linestyle->geometry_modifiers, m);
1904 return 0;
1905 }
1906
1907 /**
1908 * Reinsert \a modifier in modifier list with an offset of \a direction.
1909 * \return if position of \a modifier has changed.
1910 */
BKE_linestyle_color_modifier_move(FreestyleLineStyle * linestyle,LineStyleModifier * modifier,int direction)1911 bool BKE_linestyle_color_modifier_move(FreestyleLineStyle *linestyle,
1912 LineStyleModifier *modifier,
1913 int direction)
1914 {
1915 return BLI_listbase_link_move(&linestyle->color_modifiers, modifier, direction);
1916 }
BKE_linestyle_alpha_modifier_move(FreestyleLineStyle * linestyle,LineStyleModifier * modifier,int direction)1917 bool BKE_linestyle_alpha_modifier_move(FreestyleLineStyle *linestyle,
1918 LineStyleModifier *modifier,
1919 int direction)
1920 {
1921 return BLI_listbase_link_move(&linestyle->alpha_modifiers, modifier, direction);
1922 }
BKE_linestyle_thickness_modifier_move(FreestyleLineStyle * linestyle,LineStyleModifier * modifier,int direction)1923 bool BKE_linestyle_thickness_modifier_move(FreestyleLineStyle *linestyle,
1924 LineStyleModifier *modifier,
1925 int direction)
1926 {
1927 return BLI_listbase_link_move(&linestyle->thickness_modifiers, modifier, direction);
1928 }
BKE_linestyle_geometry_modifier_move(FreestyleLineStyle * linestyle,LineStyleModifier * modifier,int direction)1929 bool BKE_linestyle_geometry_modifier_move(FreestyleLineStyle *linestyle,
1930 LineStyleModifier *modifier,
1931 int direction)
1932 {
1933 return BLI_listbase_link_move(&linestyle->geometry_modifiers, modifier, direction);
1934 }
1935
BKE_linestyle_modifier_list_color_ramps(FreestyleLineStyle * linestyle,ListBase * listbase)1936 void BKE_linestyle_modifier_list_color_ramps(FreestyleLineStyle *linestyle, ListBase *listbase)
1937 {
1938 LineStyleModifier *m;
1939 ColorBand *color_ramp;
1940 LinkData *link;
1941
1942 BLI_listbase_clear(listbase);
1943
1944 for (m = (LineStyleModifier *)linestyle->color_modifiers.first; m; m = m->next) {
1945 switch (m->type) {
1946 case LS_MODIFIER_ALONG_STROKE:
1947 color_ramp = ((LineStyleColorModifier_AlongStroke *)m)->color_ramp;
1948 break;
1949 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
1950 color_ramp = ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp;
1951 break;
1952 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
1953 color_ramp = ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp;
1954 break;
1955 case LS_MODIFIER_MATERIAL:
1956 color_ramp = ((LineStyleColorModifier_Material *)m)->color_ramp;
1957 break;
1958 default:
1959 continue;
1960 }
1961 link = (LinkData *)MEM_callocN(sizeof(LinkData), "link to color ramp");
1962 link->data = color_ramp;
1963 BLI_addtail(listbase, link);
1964 }
1965 }
1966
BKE_linestyle_path_to_color_ramp(FreestyleLineStyle * linestyle,ColorBand * color_ramp)1967 char *BKE_linestyle_path_to_color_ramp(FreestyleLineStyle *linestyle, ColorBand *color_ramp)
1968 {
1969 LineStyleModifier *m;
1970 bool found = false;
1971
1972 for (m = (LineStyleModifier *)linestyle->color_modifiers.first; m; m = m->next) {
1973 switch (m->type) {
1974 case LS_MODIFIER_ALONG_STROKE:
1975 if (color_ramp == ((LineStyleColorModifier_AlongStroke *)m)->color_ramp) {
1976 found = true;
1977 }
1978 break;
1979 case LS_MODIFIER_DISTANCE_FROM_CAMERA:
1980 if (color_ramp == ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp) {
1981 found = true;
1982 }
1983 break;
1984 case LS_MODIFIER_DISTANCE_FROM_OBJECT:
1985 if (color_ramp == ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp) {
1986 found = true;
1987 }
1988 break;
1989 case LS_MODIFIER_MATERIAL:
1990 if (color_ramp == ((LineStyleColorModifier_Material *)m)->color_ramp) {
1991 found = true;
1992 }
1993 break;
1994 case LS_MODIFIER_TANGENT:
1995 if (color_ramp == ((LineStyleColorModifier_Tangent *)m)->color_ramp) {
1996 found = true;
1997 }
1998 break;
1999 case LS_MODIFIER_NOISE:
2000 if (color_ramp == ((LineStyleColorModifier_Noise *)m)->color_ramp) {
2001 found = true;
2002 }
2003 break;
2004 case LS_MODIFIER_CREASE_ANGLE:
2005 if (color_ramp == ((LineStyleColorModifier_CreaseAngle *)m)->color_ramp) {
2006 found = true;
2007 }
2008 break;
2009 case LS_MODIFIER_CURVATURE_3D:
2010 if (color_ramp == ((LineStyleColorModifier_Curvature_3D *)m)->color_ramp) {
2011 found = true;
2012 }
2013 break;
2014 }
2015
2016 if (found) {
2017 char name_esc[sizeof(m->name) * 2];
2018 BLI_strescape(name_esc, m->name, sizeof(name_esc));
2019 return BLI_sprintfN("color_modifiers[\"%s\"].color_ramp", name_esc);
2020 }
2021 }
2022 printf("BKE_linestyle_path_to_color_ramp: No color ramps correspond to the given pointer.\n");
2023 return NULL;
2024 }
2025
BKE_linestyle_use_textures(FreestyleLineStyle * linestyle,const bool use_shading_nodes)2026 bool BKE_linestyle_use_textures(FreestyleLineStyle *linestyle, const bool use_shading_nodes)
2027 {
2028 if (use_shading_nodes) {
2029 if (linestyle && linestyle->use_nodes && linestyle->nodetree) {
2030 bNode *node;
2031
2032 for (node = linestyle->nodetree->nodes.first; node; node = node->next) {
2033 if (node->typeinfo->nclass == NODE_CLASS_TEXTURE) {
2034 return true;
2035 }
2036 }
2037 }
2038 }
2039 else {
2040 if (linestyle && (linestyle->flag & LS_TEXTURE)) {
2041 return (linestyle->mtex[0] != NULL);
2042 }
2043 }
2044 return false;
2045 }
2046
BKE_linestyle_default_shader(const bContext * C,FreestyleLineStyle * linestyle)2047 void BKE_linestyle_default_shader(const bContext *C, FreestyleLineStyle *linestyle)
2048 {
2049 bNode *uv_along_stroke, *input_texure, *output_linestyle;
2050 bNodeSocket *fromsock, *tosock;
2051 bNodeTree *ntree;
2052
2053 BLI_assert(linestyle->nodetree == NULL);
2054
2055 ntree = ntreeAddTree(NULL, "stroke_shader", "ShaderNodeTree");
2056
2057 linestyle->nodetree = ntree;
2058
2059 uv_along_stroke = nodeAddStaticNode(C, ntree, SH_NODE_UVALONGSTROKE);
2060 uv_along_stroke->locx = 0.0f;
2061 uv_along_stroke->locy = 300.0f;
2062 uv_along_stroke->custom1 = 0; /* use_tips */
2063
2064 input_texure = nodeAddStaticNode(C, ntree, SH_NODE_TEX_IMAGE);
2065 input_texure->locx = 200.0f;
2066 input_texure->locy = 300.0f;
2067
2068 output_linestyle = nodeAddStaticNode(C, ntree, SH_NODE_OUTPUT_LINESTYLE);
2069 output_linestyle->locx = 400.0f;
2070 output_linestyle->locy = 300.0f;
2071 output_linestyle->custom1 = MA_RAMP_BLEND;
2072 output_linestyle->custom2 = 0; /* use_clamp */
2073
2074 nodeSetActive(ntree, input_texure);
2075
2076 fromsock = BLI_findlink(&uv_along_stroke->outputs, 0); /* UV */
2077 tosock = BLI_findlink(&input_texure->inputs, 0); /* UV */
2078 nodeAddLink(ntree, uv_along_stroke, fromsock, input_texure, tosock);
2079
2080 fromsock = BLI_findlink(&input_texure->outputs, 0); /* Color */
2081 tosock = BLI_findlink(&output_linestyle->inputs, 0); /* Color */
2082 nodeAddLink(ntree, input_texure, fromsock, output_linestyle, tosock);
2083
2084 ntreeUpdateTree(CTX_data_main(C), ntree);
2085 }
2086