Blender  V3.3
linestyle.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2010 Blender Foundation. All rights reserved. */
3 
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 
12 #include "MEM_guardedalloc.h"
13 
14 #include "DNA_defaults.h"
15 #include "DNA_material_types.h" /* for ramp blend */
16 #include "DNA_object_types.h"
17 #include "DNA_texture_types.h"
18 
19 #include "BLI_blenlib.h"
20 #include "BLI_math.h"
21 #include "BLI_string_utils.h"
22 #include "BLI_utildefines.h"
23 
24 #include "BLT_translation.h"
25 
26 #include "BKE_anim_data.h"
27 #include "BKE_colorband.h"
28 #include "BKE_colortools.h"
29 #include "BKE_context.h"
30 #include "BKE_freestyle.h"
31 #include "BKE_idtype.h"
32 #include "BKE_lib_id.h"
33 #include "BKE_lib_query.h"
34 #include "BKE_linestyle.h"
35 #include "BKE_main.h"
36 #include "BKE_node.h"
37 #include "BKE_node_tree_update.h"
38 #include "BKE_texture.h"
39 
40 #include "BLO_read_write.h"
41 
42 static void linestyle_init_data(ID *id)
43 {
45 
47 
49 
51 }
52 
53 static void linestyle_copy_data(Main *bmain, ID *id_dst, const ID *id_src, const int flag)
54 {
55  FreestyleLineStyle *linestyle_dst = (FreestyleLineStyle *)id_dst;
56  const FreestyleLineStyle *linestyle_src = (const FreestyleLineStyle *)id_src;
57 
58  /* We never handle user-count here for own data. */
59  const int flag_subdata = flag | LIB_ID_CREATE_NO_USER_REFCOUNT;
60  /* We always need allocation of our private ID data. */
61  const int flag_private_id_data = flag & ~LIB_ID_CREATE_NO_ALLOCATE;
62 
63  for (int a = 0; a < MAX_MTEX; a++) {
64  if (linestyle_src->mtex[a]) {
65  linestyle_dst->mtex[a] = MEM_mallocN(sizeof(*linestyle_dst->mtex[a]), __func__);
66  *linestyle_dst->mtex[a] = *linestyle_src->mtex[a];
67  }
68  }
69 
70  if (linestyle_src->nodetree) {
71  BKE_id_copy_ex(bmain,
72  (ID *)linestyle_src->nodetree,
73  (ID **)&linestyle_dst->nodetree,
74  flag_private_id_data);
75  }
76 
77  LineStyleModifier *linestyle_modifier;
78  BLI_listbase_clear(&linestyle_dst->color_modifiers);
79  for (linestyle_modifier = (LineStyleModifier *)linestyle_src->color_modifiers.first;
80  linestyle_modifier;
81  linestyle_modifier = linestyle_modifier->next) {
82  BKE_linestyle_color_modifier_copy(linestyle_dst, linestyle_modifier, flag_subdata);
83  }
84 
85  BLI_listbase_clear(&linestyle_dst->alpha_modifiers);
86  for (linestyle_modifier = (LineStyleModifier *)linestyle_src->alpha_modifiers.first;
87  linestyle_modifier;
88  linestyle_modifier = linestyle_modifier->next) {
89  BKE_linestyle_alpha_modifier_copy(linestyle_dst, linestyle_modifier, flag_subdata);
90  }
91 
92  BLI_listbase_clear(&linestyle_dst->thickness_modifiers);
93  for (linestyle_modifier = (LineStyleModifier *)linestyle_src->thickness_modifiers.first;
94  linestyle_modifier;
95  linestyle_modifier = linestyle_modifier->next) {
96  BKE_linestyle_thickness_modifier_copy(linestyle_dst, linestyle_modifier, flag_subdata);
97  }
98 
99  BLI_listbase_clear(&linestyle_dst->geometry_modifiers);
100  for (linestyle_modifier = (LineStyleModifier *)linestyle_src->geometry_modifiers.first;
101  linestyle_modifier;
102  linestyle_modifier = linestyle_modifier->next) {
103  BKE_linestyle_geometry_modifier_copy(linestyle_dst, linestyle_modifier, flag_subdata);
104  }
105 }
106 
107 static void linestyle_free_data(ID *id)
108 {
110  LineStyleModifier *linestyle_modifier;
111 
112  for (int material_slot_index = 0; material_slot_index < MAX_MTEX; material_slot_index++) {
113  MEM_SAFE_FREE(linestyle->mtex[material_slot_index]);
114  }
115 
116  /* is no lib link block, but linestyle extension */
117  if (linestyle->nodetree) {
121  }
122 
123  while ((linestyle_modifier = (LineStyleModifier *)linestyle->color_modifiers.first)) {
124  BKE_linestyle_color_modifier_remove(linestyle, linestyle_modifier);
125  }
126  while ((linestyle_modifier = (LineStyleModifier *)linestyle->alpha_modifiers.first)) {
127  BKE_linestyle_alpha_modifier_remove(linestyle, linestyle_modifier);
128  }
129  while ((linestyle_modifier = (LineStyleModifier *)linestyle->thickness_modifiers.first)) {
131  }
132  while ((linestyle_modifier = (LineStyleModifier *)linestyle->geometry_modifiers.first)) {
134  }
135 }
136 
138 {
140 
141  for (int i = 0; i < MAX_MTEX; i++) {
142  if (linestyle->mtex[i]) {
145  }
146  }
147  if (linestyle->nodetree) {
148  /* nodetree **are owned by IDs**, treat them as mere sub-data and not real ID! */
151  }
152 
154  if (lsm->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
156  lsm;
157  if (p->target) {
159  }
160  }
161  }
163  if (lsm->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
165  lsm;
166  if (p->target) {
168  }
169  }
170  }
172  if (lsm->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
175  if (p->target) {
177  }
178  }
179  }
180 }
181 
182 static void write_linestyle_color_modifiers(BlendWriter *writer, ListBase *modifiers)
183 {
185 
186  for (m = modifiers->first; m; m = m->next) {
187  int struct_nr;
188  switch (m->type) {
190  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleColorModifier_AlongStroke);
191  break;
193  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleColorModifier_DistanceFromCamera);
194  break;
196  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleColorModifier_DistanceFromObject);
197  break;
199  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleColorModifier_Material);
200  break;
201  case LS_MODIFIER_TANGENT:
202  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleColorModifier_Tangent);
203  break;
204  case LS_MODIFIER_NOISE:
205  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleColorModifier_Noise);
206  break;
208  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleColorModifier_CreaseAngle);
209  break;
211  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleColorModifier_Curvature_3D);
212  break;
213  default:
214  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleModifier); /* this should not happen */
215  }
216  BLO_write_struct_by_id(writer, struct_nr, m);
217  }
218  for (m = modifiers->first; m; m = m->next) {
219  switch (m->type) {
222  break;
225  writer, ColorBand, ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp);
226  break;
229  writer, ColorBand, ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp);
230  break;
232  BLO_write_struct(writer, ColorBand, ((LineStyleColorModifier_Material *)m)->color_ramp);
233  break;
234  case LS_MODIFIER_TANGENT:
235  BLO_write_struct(writer, ColorBand, ((LineStyleColorModifier_Tangent *)m)->color_ramp);
236  break;
237  case LS_MODIFIER_NOISE:
238  BLO_write_struct(writer, ColorBand, ((LineStyleColorModifier_Noise *)m)->color_ramp);
239  break;
242  break;
245  writer, ColorBand, ((LineStyleColorModifier_Curvature_3D *)m)->color_ramp);
246  break;
247  }
248  }
249 }
250 
251 static void write_linestyle_alpha_modifiers(BlendWriter *writer, ListBase *modifiers)
252 {
254 
255  for (m = modifiers->first; m; m = m->next) {
256  int struct_nr;
257  switch (m->type) {
259  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleAlphaModifier_AlongStroke);
260  break;
262  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleAlphaModifier_DistanceFromCamera);
263  break;
265  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleAlphaModifier_DistanceFromObject);
266  break;
268  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleAlphaModifier_Material);
269  break;
270  case LS_MODIFIER_TANGENT:
271  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleAlphaModifier_Tangent);
272  break;
273  case LS_MODIFIER_NOISE:
274  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleAlphaModifier_Noise);
275  break;
277  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleAlphaModifier_CreaseAngle);
278  break;
280  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleAlphaModifier_Curvature_3D);
281  break;
282  default:
283  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleModifier); /* this should not happen */
284  }
285  BLO_write_struct_by_id(writer, struct_nr, m);
286  }
287  for (m = modifiers->first; m; m = m->next) {
288  switch (m->type) {
291  break;
295  break;
299  break;
302  break;
303  case LS_MODIFIER_TANGENT:
305  break;
306  case LS_MODIFIER_NOISE:
308  break;
311  break;
314  break;
315  }
316  }
317 }
318 
320 {
322 
323  for (m = modifiers->first; m; m = m->next) {
324  int struct_nr;
325  switch (m->type) {
327  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_AlongStroke);
328  break;
330  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_DistanceFromCamera);
331  break;
333  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_DistanceFromObject);
334  break;
336  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_Material);
337  break;
339  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_Calligraphy);
340  break;
341  case LS_MODIFIER_TANGENT:
342  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_Tangent);
343  break;
344  case LS_MODIFIER_NOISE:
345  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_Noise);
346  break;
348  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_CreaseAngle);
349  break;
351  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleThicknessModifier_Curvature_3D);
352  break;
353  default:
354  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleModifier); /* this should not happen */
355  }
356  BLO_write_struct_by_id(writer, struct_nr, m);
357  }
358  for (m = modifiers->first; m; m = m->next) {
359  switch (m->type) {
362  break;
366  break;
370  break;
373  break;
374  case LS_MODIFIER_TANGENT:
376  break;
379  break;
383  break;
384  }
385  }
386 }
387 
389 {
391 
392  for (m = modifiers->first; m; m = m->next) {
393  int struct_nr;
394  switch (m->type) {
396  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_Sampling);
397  break;
399  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_BezierCurve);
400  break;
402  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_SinusDisplacement);
403  break;
405  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_SpatialNoise);
406  break;
408  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_PerlinNoise1D);
409  break;
411  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_PerlinNoise2D);
412  break;
414  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_BackboneStretcher);
415  break;
417  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_TipRemover);
418  break;
420  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_Polygonalization);
421  break;
423  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_GuidingLines);
424  break;
426  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_Blueprint);
427  break;
429  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_2DOffset);
430  break;
432  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_2DTransform);
433  break;
435  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleGeometryModifier_Simplification);
436  break;
437  default:
438  struct_nr = SDNA_TYPE_FROM_STRUCT(LineStyleModifier); /* this should not happen */
439  }
440  BLO_write_struct_by_id(writer, struct_nr, m);
441  }
442 }
443 
444 static void linestyle_blend_write(BlendWriter *writer, ID *id, const void *id_address)
445 {
447 
448  BLO_write_id_struct(writer, FreestyleLineStyle, id_address, &linestyle->id);
449  BKE_id_blend_write(writer, &linestyle->id);
450 
451  if (linestyle->adt) {
453  }
454 
459  for (int a = 0; a < MAX_MTEX; a++) {
460  if (linestyle->mtex[a]) {
461  BLO_write_struct(writer, MTex, linestyle->mtex[a]);
462  }
463  }
464  if (linestyle->nodetree) {
467  }
468 }
469 
471  LineStyleModifier *modifier)
472 {
473  switch (modifier->type) {
476  BLO_read_data_address(reader, &m->color_ramp);
477  break;
478  }
481  modifier;
482  BLO_read_data_address(reader, &m->color_ramp);
483  break;
484  }
487  modifier;
488  BLO_read_data_address(reader, &m->color_ramp);
489  break;
490  }
491  case LS_MODIFIER_MATERIAL: {
493  BLO_read_data_address(reader, &m->color_ramp);
494  break;
495  }
496  case LS_MODIFIER_TANGENT: {
498  BLO_read_data_address(reader, &m->color_ramp);
499  break;
500  }
501  case LS_MODIFIER_NOISE: {
503  BLO_read_data_address(reader, &m->color_ramp);
504  break;
505  }
508  BLO_read_data_address(reader, &m->color_ramp);
509  break;
510  }
513  BLO_read_data_address(reader, &m->color_ramp);
514  break;
515  }
516  }
517 }
518 
520  LineStyleModifier *modifier)
521 {
522  switch (modifier->type) {
525  BLO_read_data_address(reader, &m->curve);
527  break;
528  }
531  modifier;
532  BLO_read_data_address(reader, &m->curve);
534  break;
535  }
538  modifier;
539  BLO_read_data_address(reader, &m->curve);
541  break;
542  }
543  case LS_MODIFIER_MATERIAL: {
545  BLO_read_data_address(reader, &m->curve);
547  break;
548  }
549  case LS_MODIFIER_TANGENT: {
551  BLO_read_data_address(reader, &m->curve);
553  break;
554  }
555  case LS_MODIFIER_NOISE: {
557  BLO_read_data_address(reader, &m->curve);
559  break;
560  }
563  BLO_read_data_address(reader, &m->curve);
565  break;
566  }
569  BLO_read_data_address(reader, &m->curve);
571  break;
572  }
573  }
574 }
575 
577  LineStyleModifier *modifier)
578 {
579  switch (modifier->type) {
582  modifier;
583  BLO_read_data_address(reader, &m->curve);
585  break;
586  }
590  BLO_read_data_address(reader, &m->curve);
592  break;
593  }
597  BLO_read_data_address(reader, &m->curve);
599  break;
600  }
601  case LS_MODIFIER_MATERIAL: {
603  BLO_read_data_address(reader, &m->curve);
605  break;
606  }
607  case LS_MODIFIER_TANGENT: {
609  BLO_read_data_address(reader, &m->curve);
611  break;
612  }
615  modifier;
616  BLO_read_data_address(reader, &m->curve);
618  break;
619  }
622  modifier;
623  BLO_read_data_address(reader, &m->curve);
625  break;
626  }
627  }
628 }
629 
631  LineStyleModifier *UNUSED(modifier))
632 {
633 }
634 
636 {
638 
643  direct_link_linestyle_color_modifier(reader, modifier);
644  }
647  direct_link_linestyle_alpha_modifier(reader, modifier);
648  }
652  }
655  direct_link_linestyle_geometry_modifier(reader, modifier);
656  }
657  for (int a = 0; a < MAX_MTEX; a++) {
659  }
660 }
661 
662 static void linestyle_blend_read_lib(BlendLibReader *reader, ID *id)
663 {
665 
667  switch (m->type) {
671  BLO_read_id_address(reader, linestyle->id.lib, &cm->target);
672  break;
673  }
674  }
675  }
677  switch (m->type) {
681  BLO_read_id_address(reader, linestyle->id.lib, &am->target);
682  break;
683  }
684  }
685  }
687  switch (m->type) {
691  BLO_read_id_address(reader, linestyle->id.lib, &tm->target);
692  break;
693  }
694  }
695  }
696  for (int a = 0; a < MAX_MTEX; a++) {
697  MTex *mtex = linestyle->mtex[a];
698  if (mtex) {
699  BLO_read_id_address(reader, linestyle->id.lib, &mtex->tex);
700  BLO_read_id_address(reader, linestyle->id.lib, &mtex->object);
701  }
702  }
703 }
704 
705 static void linestyle_blend_read_expand(BlendExpander *expander, ID *id)
706 {
708 
709  for (int a = 0; a < MAX_MTEX; a++) {
710  if (linestyle->mtex[a]) {
711  BLO_expand(expander, linestyle->mtex[a]->tex);
712  BLO_expand(expander, linestyle->mtex[a]->object);
713  }
714  }
715 
717  if (m->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
718  BLO_expand(expander, ((LineStyleColorModifier_DistanceFromObject *)m)->target);
719  }
720  }
722  if (m->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
723  BLO_expand(expander, ((LineStyleAlphaModifier_DistanceFromObject *)m)->target);
724  }
725  }
727  if (m->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
729  }
730  }
731 }
732 
734  .id_code = ID_LS,
735  .id_filter = FILTER_ID_LS,
736  .main_listbase_index = INDEX_ID_LS,
737  .struct_size = sizeof(FreestyleLineStyle),
738  .name = "FreestyleLineStyle",
739  .name_plural = "linestyles",
740  .translation_context = BLT_I18NCONTEXT_ID_FREESTYLELINESTYLE,
742  .asset_type_info = NULL,
743 
745  .copy_data = linestyle_copy_data,
746  .free_data = linestyle_free_data,
747  .make_local = NULL,
748  .foreach_id = linestyle_foreach_id,
749  .foreach_cache = NULL,
750  .foreach_path = NULL,
751  .owner_get = NULL,
752 
753  .blend_write = linestyle_blend_write,
754  .blend_read_data = linestyle_blend_read_data,
755  .blend_read_lib = linestyle_blend_read_lib,
756  .blend_read_expand = linestyle_blend_read_expand,
757 
758  .blend_read_undo_preserve = NULL,
759 
760  .lib_override_apply_post = NULL,
761 };
762 
763 static const char *modifier_name[LS_MODIFIER_NUM] = {
764  NULL,
765  "Along Stroke",
766  "Distance from Camera",
767  "Distance from Object",
768  "Material",
769  "Sampling",
770  "Bezier Curve",
771  "Sinus Displacement",
772  "Spatial Noise",
773  "Perlin Noise 1D",
774  "Perlin Noise 2D",
775  "Backbone Stretcher",
776  "Tip Remover",
777  "Calligraphy",
778  "Polygonalization",
779  "Guiding Lines",
780  "Blueprint",
781  "2D Offset",
782  "2D Transform",
783  "Tangent",
784  "Noise",
785  "Crease Angle",
786  "Simplification",
787  "Curvature 3D",
788 };
789 
791 {
793 }
794 
795 FreestyleLineStyle *BKE_linestyle_new(struct Main *bmain, const char *name)
796 {
798 
800 
802 
803  return linestyle;
804 }
805 
807 {
808  FreestyleConfig *config = &view_layer->freestyle_config;
810  return (lineset) ? lineset->linestyle : NULL;
811 }
812 
813 static LineStyleModifier *new_modifier(const char *name, int type, size_t size)
814 {
816 
817  if (!name) {
818  name = modifier_name[type];
819  }
820  m = (LineStyleModifier *)MEM_callocN(size, "line style modifier");
821  m->type = type;
822  BLI_strncpy(m->name, name, sizeof(m->name));
823  m->influence = 1.0f;
825 
826  return m;
827 }
828 
830 {
831  BLI_addtail(lb, (void *)m);
833  lb, m, modifier_name[m->type], '.', offsetof(LineStyleModifier, name), sizeof(m->name));
834 }
835 
836 static LineStyleModifier *alloc_color_modifier(const char *name, int type)
837 {
838  size_t size;
839 
840  switch (type) {
843  break;
846  break;
849  break;
852  break;
853  case LS_MODIFIER_TANGENT:
855  break;
856  case LS_MODIFIER_NOISE:
858  break;
861  break;
864  break;
865  default:
866  return NULL; /* unknown modifier type */
867  }
868 
869  return new_modifier(name, type, size);
870 }
871 
873  const char *name,
874  int type)
875 {
877 
878  m = alloc_color_modifier(name, type);
879  if (UNLIKELY(m == NULL)) {
880  return NULL;
881  }
882  m->blend = MA_RAMP_BLEND;
883 
884  switch (type) {
886  ((LineStyleColorModifier_AlongStroke *)m)->color_ramp = BKE_colorband_add(true);
887  break;
890  ((LineStyleColorModifier_DistanceFromCamera *)m)->range_min = 0.0f;
891  ((LineStyleColorModifier_DistanceFromCamera *)m)->range_max = 10000.0f;
892  break;
896  ((LineStyleColorModifier_DistanceFromObject *)m)->range_min = 0.0f;
897  ((LineStyleColorModifier_DistanceFromObject *)m)->range_max = 10000.0f;
898  break;
900  ((LineStyleColorModifier_Material *)m)->color_ramp = BKE_colorband_add(true);
902  break;
903  case LS_MODIFIER_TANGENT:
904  ((LineStyleColorModifier_Tangent *)m)->color_ramp = BKE_colorband_add(true);
905  break;
906  case LS_MODIFIER_NOISE:
907  ((LineStyleColorModifier_Noise *)m)->color_ramp = BKE_colorband_add(true);
908  ((LineStyleColorModifier_Noise *)m)->amplitude = 10.0f;
909  ((LineStyleColorModifier_Noise *)m)->period = 10.0f;
910  ((LineStyleColorModifier_Noise *)m)->seed = 512;
911  break;
913  ((LineStyleColorModifier_CreaseAngle *)m)->color_ramp = BKE_colorband_add(true);
914  ((LineStyleColorModifier_CreaseAngle *)m)->min_angle = 0.0f;
915  ((LineStyleColorModifier_CreaseAngle *)m)->max_angle = DEG2RADF(180.0f);
916  break;
918  ((LineStyleColorModifier_Curvature_3D *)m)->color_ramp = BKE_colorband_add(true);
919  ((LineStyleColorModifier_Curvature_3D *)m)->min_curvature = 0.0f;
920  ((LineStyleColorModifier_Curvature_3D *)m)->max_curvature = 0.5f;
921  break;
922  default:
923  return NULL; /* unknown modifier type */
924  }
926 
927  return m;
928 }
929 
931  const LineStyleModifier *m,
932  const int flag)
933 {
934  LineStyleModifier *new_m;
935 
936  new_m = alloc_color_modifier(m->name, m->type);
937  if (UNLIKELY(new_m == NULL)) {
938  return NULL;
939  }
940  new_m->influence = m->influence;
941  new_m->flags = m->flags;
942  new_m->blend = m->blend;
943 
944  switch (m->type) {
949  break;
950  }
953  m;
955  new_m;
957  q->range_min = p->range_min;
958  q->range_max = p->range_max;
959  break;
960  }
963  m;
965  new_m;
966  q->target = p->target;
967  if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
968  id_us_plus((ID *)q->target);
969  }
971  q->range_min = p->range_min;
972  q->range_max = p->range_max;
973  break;
974  }
975  case LS_MODIFIER_MATERIAL: {
979  q->flags = p->flags;
980  q->mat_attr = p->mat_attr;
981  break;
982  }
983  case LS_MODIFIER_TANGENT: {
987  break;
988  }
989  case LS_MODIFIER_NOISE: {
993  q->amplitude = p->amplitude;
994  q->period = p->period;
995  q->seed = p->seed;
996  break;
997  }
1002  q->min_angle = p->min_angle;
1003  q->max_angle = p->max_angle;
1004  break;
1005  }
1006  case LS_MODIFIER_CURVATURE_3D: {
1010  q->min_curvature = p->min_curvature;
1011  q->max_curvature = p->max_curvature;
1012  break;
1013  }
1014  default:
1015  return NULL; /* unknown modifier type */
1016  }
1018 
1019  return new_m;
1020 }
1021 
1023 {
1024  if (BLI_findindex(&linestyle->color_modifiers, m) == -1) {
1025  return -1;
1026  }
1027  switch (m->type) {
1029  MEM_freeN(((LineStyleColorModifier_AlongStroke *)m)->color_ramp);
1030  break;
1033  break;
1036  break;
1037  case LS_MODIFIER_MATERIAL:
1038  MEM_freeN(((LineStyleColorModifier_Material *)m)->color_ramp);
1039  break;
1040  case LS_MODIFIER_TANGENT:
1041  MEM_freeN(((LineStyleColorModifier_Tangent *)m)->color_ramp);
1042  break;
1043  case LS_MODIFIER_NOISE:
1044  MEM_freeN(((LineStyleColorModifier_Noise *)m)->color_ramp);
1045  break;
1047  MEM_freeN(((LineStyleColorModifier_CreaseAngle *)m)->color_ramp);
1048  break;
1050  MEM_freeN(((LineStyleColorModifier_Curvature_3D *)m)->color_ramp);
1051  break;
1052  }
1054  return 0;
1055 }
1056 
1057 static LineStyleModifier *alloc_alpha_modifier(const char *name, int type)
1058 {
1059  size_t size;
1060 
1061  switch (type) {
1064  break;
1067  break;
1070  break;
1071  case LS_MODIFIER_MATERIAL:
1073  break;
1074  case LS_MODIFIER_TANGENT:
1076  break;
1077  case LS_MODIFIER_NOISE:
1079  break;
1082  break;
1085  break;
1086  default:
1087  return NULL; /* unknown modifier type */
1088  }
1089  return new_modifier(name, type, size);
1090 }
1091 
1093  const char *name,
1094  int type)
1095 {
1096  LineStyleModifier *m;
1097 
1098  m = alloc_alpha_modifier(name, type);
1099  m->blend = LS_VALUE_BLEND;
1100 
1101  switch (type) {
1102  case LS_MODIFIER_ALONG_STROKE: {
1104  p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1105  break;
1106  }
1109  m;
1110  p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1111  p->range_min = 0.0f;
1112  p->range_max = 10000.0f;
1113  break;
1114  }
1117  m;
1118  p->target = NULL;
1119  p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1120  p->range_min = 0.0f;
1121  p->range_max = 10000.0f;
1122  break;
1123  }
1124  case LS_MODIFIER_MATERIAL: {
1126  p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1128  break;
1129  }
1130  case LS_MODIFIER_TANGENT: {
1132  p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1133  break;
1134  }
1135  case LS_MODIFIER_NOISE: {
1137  p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1138  ((LineStyleAlphaModifier_Noise *)m)->amplitude = 10.0f;
1139  ((LineStyleAlphaModifier_Noise *)m)->period = 10.0f;
1140  ((LineStyleAlphaModifier_Noise *)m)->seed = 512;
1141  break;
1142  }
1143  case LS_MODIFIER_CREASE_ANGLE: {
1145  p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1146  ((LineStyleAlphaModifier_CreaseAngle *)m)->min_angle = 0.0f;
1147  ((LineStyleAlphaModifier_CreaseAngle *)m)->max_angle = DEG2RADF(180.0f);
1148  break;
1149  }
1150  case LS_MODIFIER_CURVATURE_3D: {
1152  p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1153  ((LineStyleAlphaModifier_Curvature_3D *)m)->min_curvature = 0.0f;
1154  ((LineStyleAlphaModifier_Curvature_3D *)m)->max_curvature = 0.5f;
1155  break;
1156  }
1157  default:
1158  return NULL; /* unknown modifier type */
1159  }
1161 
1162  return m;
1163 }
1164 
1166  const LineStyleModifier *m,
1167  const int UNUSED(flag))
1168 {
1169  LineStyleModifier *new_m;
1170 
1171  new_m = alloc_alpha_modifier(m->name, m->type);
1172  new_m->influence = m->influence;
1173  new_m->flags = m->flags;
1174  new_m->blend = m->blend;
1175 
1176  switch (m->type) {
1177  case LS_MODIFIER_ALONG_STROKE: {
1181  q->flags = p->flags;
1182  break;
1183  }
1186  m;
1188  new_m;
1190  q->flags = p->flags;
1191  q->range_min = p->range_min;
1192  q->range_max = p->range_max;
1193  break;
1194  }
1197  m;
1199  new_m;
1200  if (p->target) {
1201  id_us_plus(&p->target->id);
1202  }
1203  q->target = p->target;
1205  q->flags = p->flags;
1206  q->range_min = p->range_min;
1207  q->range_max = p->range_max;
1208  break;
1209  }
1210  case LS_MODIFIER_MATERIAL: {
1214  q->flags = p->flags;
1215  q->mat_attr = p->mat_attr;
1216  break;
1217  }
1218  case LS_MODIFIER_TANGENT: {
1222  q->flags = p->flags;
1223  break;
1224  }
1225  case LS_MODIFIER_NOISE: {
1229  q->flags = p->flags;
1230  q->amplitude = p->amplitude;
1231  q->period = p->period;
1232  q->seed = p->seed;
1233  break;
1234  }
1235  case LS_MODIFIER_CREASE_ANGLE: {
1239  q->flags = p->flags;
1240  q->min_angle = p->min_angle;
1241  q->max_angle = p->max_angle;
1242  break;
1243  }
1244  case LS_MODIFIER_CURVATURE_3D: {
1248  q->flags = p->flags;
1249  q->min_curvature = p->min_curvature;
1250  q->max_curvature = p->max_curvature;
1251  break;
1252  }
1253  default:
1254  return NULL; /* unknown modifier type */
1255  }
1257 
1258  return new_m;
1259 }
1260 
1262 {
1263  if (BLI_findindex(&linestyle->alpha_modifiers, m) == -1) {
1264  return -1;
1265  }
1266  switch (m->type) {
1269  break;
1272  break;
1275  break;
1276  case LS_MODIFIER_MATERIAL:
1278  break;
1279  case LS_MODIFIER_TANGENT:
1281  break;
1282  case LS_MODIFIER_NOISE:
1284  break;
1287  break;
1290  break;
1291  }
1293  return 0;
1294 }
1295 
1296 static LineStyleModifier *alloc_thickness_modifier(const char *name, int type)
1297 {
1298  size_t size;
1299 
1300  switch (type) {
1303  break;
1306  break;
1309  break;
1310  case LS_MODIFIER_MATERIAL:
1312  break;
1315  break;
1316  case LS_MODIFIER_TANGENT:
1318  break;
1319  case LS_MODIFIER_NOISE:
1321  break;
1324  break;
1327  break;
1328  default:
1329  return NULL; /* unknown modifier type */
1330  }
1331 
1332  return new_modifier(name, type, size);
1333 }
1334 
1336  const char *name,
1337  int type)
1338 {
1339  LineStyleModifier *m;
1340 
1341  m = alloc_thickness_modifier(name, type);
1342  m->blend = LS_VALUE_BLEND;
1343 
1344  switch (type) {
1345  case LS_MODIFIER_ALONG_STROKE: {
1347  p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1348  p->value_min = 0.0f;
1349  p->value_max = 1.0f;
1350  break;
1351  }
1355  p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1356  p->range_min = 0.0f;
1357  p->range_max = 1000.0f;
1358  p->value_min = 0.0f;
1359  p->value_max = 1.0f;
1360  break;
1361  }
1365  p->target = NULL;
1366  p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1367  p->range_min = 0.0f;
1368  p->range_max = 1000.0f;
1369  p->value_min = 0.0f;
1370  p->value_max = 1.0f;
1371  break;
1372  }
1373  case LS_MODIFIER_MATERIAL: {
1375  p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1377  p->value_min = 0.0f;
1378  p->value_max = 1.0f;
1379  break;
1380  }
1381  case LS_MODIFIER_CALLIGRAPHY: {
1383  p->min_thickness = 1.0f;
1384  p->max_thickness = 10.0f;
1385  p->orientation = DEG2RADF(60.0f);
1386  break;
1387  }
1388  case LS_MODIFIER_TANGENT: {
1390  p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1391  p->min_thickness = 1.0f;
1392  p->max_thickness = 10.0f;
1393  break;
1394  }
1395  case LS_MODIFIER_NOISE: {
1397  p->period = 10.0f;
1398  p->amplitude = 10.0f;
1399  p->seed = 512;
1401  break;
1402  }
1403  case LS_MODIFIER_CREASE_ANGLE: {
1405  p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1406  p->min_angle = 0.0f;
1407  p->max_angle = DEG2RADF(180.0f);
1408  p->min_thickness = 1.0f;
1409  p->max_thickness = 10.0f;
1410  break;
1411  }
1412  case LS_MODIFIER_CURVATURE_3D: {
1414  p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1415  p->min_curvature = 0.0f;
1416  p->max_curvature = 0.5f;
1417  p->min_thickness = 1.0f;
1418  p->max_thickness = 10.0f;
1419  break;
1420  }
1421  default:
1422  return NULL; /* unknown modifier type */
1423  }
1425 
1426  return m;
1427 }
1428 
1430  const LineStyleModifier *m,
1431  const int flag)
1432 {
1433  LineStyleModifier *new_m;
1434 
1435  new_m = alloc_thickness_modifier(m->name, m->type);
1436  if (!new_m) {
1437  return NULL;
1438  }
1439  new_m->influence = m->influence;
1440  new_m->flags = m->flags;
1441  new_m->blend = m->blend;
1442 
1443  switch (m->type) {
1444  case LS_MODIFIER_ALONG_STROKE: {
1448  q->flags = p->flags;
1449  q->value_min = p->value_min;
1450  q->value_max = p->value_max;
1451  break;
1452  }
1459  q->flags = p->flags;
1460  q->range_min = p->range_min;
1461  q->range_max = p->range_max;
1462  q->value_min = p->value_min;
1463  q->value_max = p->value_max;
1464  break;
1465  }
1471  q->target = p->target;
1472  if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
1473  id_us_plus((ID *)q->target);
1474  }
1476  q->flags = p->flags;
1477  q->range_min = p->range_min;
1478  q->range_max = p->range_max;
1479  q->value_min = p->value_min;
1480  q->value_max = p->value_max;
1481  break;
1482  }
1483  case LS_MODIFIER_MATERIAL: {
1487  q->flags = p->flags;
1488  q->mat_attr = p->mat_attr;
1489  q->value_min = p->value_min;
1490  q->value_max = p->value_max;
1491  break;
1492  }
1493  case LS_MODIFIER_CALLIGRAPHY: {
1496  q->min_thickness = p->min_thickness;
1497  q->max_thickness = p->max_thickness;
1498  q->orientation = p->orientation;
1499  break;
1500  }
1501  case LS_MODIFIER_TANGENT: {
1505  q->flags = p->flags;
1506  q->min_thickness = p->min_thickness;
1507  q->max_thickness = p->max_thickness;
1508  break;
1509  }
1510  case LS_MODIFIER_NOISE: {
1513  q->amplitude = p->amplitude;
1514  q->period = p->period;
1515  q->seed = p->seed;
1516  q->flags = p->flags;
1517  break;
1518  }
1519  case LS_MODIFIER_CURVATURE_3D: {
1522  new_m;
1524  q->flags = p->flags;
1525  q->min_curvature = p->min_curvature;
1526  q->max_curvature = p->max_curvature;
1527  q->min_thickness = p->min_thickness;
1528  q->max_thickness = p->max_thickness;
1529  break;
1530  }
1531  case LS_MODIFIER_CREASE_ANGLE: {
1535  q->flags = p->flags;
1536  q->min_angle = p->min_angle;
1537  q->max_angle = p->max_angle;
1538  q->min_thickness = p->min_thickness;
1539  q->max_thickness = p->max_thickness;
1540  break;
1541  }
1542  default:
1543  return NULL; /* unknown modifier type */
1544  }
1546 
1547  return new_m;
1548 }
1549 
1551 {
1552  if (BLI_findindex(&linestyle->thickness_modifiers, m) == -1) {
1553  return -1;
1554  }
1555  switch (m->type) {
1558  break;
1561  break;
1564  break;
1565  case LS_MODIFIER_MATERIAL:
1567  break;
1569  break;
1570  case LS_MODIFIER_TANGENT:
1572  break;
1573  case LS_MODIFIER_NOISE:
1574  break;
1576  break;
1578  break;
1579  }
1581  return 0;
1582 }
1583 
1584 static LineStyleModifier *alloc_geometry_modifier(const char *name, int type)
1585 {
1586  size_t size;
1587 
1588  switch (type) {
1589  case LS_MODIFIER_SAMPLING:
1591  break;
1594  break;
1597  break;
1600  break;
1603  break;
1606  break;
1609  break;
1612  break;
1615  break;
1618  break;
1619  case LS_MODIFIER_BLUEPRINT:
1621  break;
1622  case LS_MODIFIER_2D_OFFSET:
1624  break;
1627  break;
1630  break;
1631  default:
1632  return NULL; /* unknown modifier type */
1633  }
1634 
1635  return new_modifier(name, type, size);
1636 }
1637 
1639  const char *name,
1640  int type)
1641 {
1642  LineStyleModifier *m;
1643 
1644  m = alloc_geometry_modifier(name, type);
1645 
1646  switch (type) {
1647  case LS_MODIFIER_SAMPLING: {
1649  p->sampling = 10.0f;
1650  break;
1651  }
1652  case LS_MODIFIER_BEZIER_CURVE: {
1654  p->error = 10.0f;
1655  break;
1656  }
1660  p->wavelength = 20.0f;
1661  p->amplitude = 5.0f;
1662  p->phase = 0.0f;
1663  break;
1664  }
1667  p->amplitude = 5.0f;
1668  p->scale = 20.0f;
1669  p->octaves = 4;
1671  break;
1672  }
1675  p->frequency = 10.0f;
1676  p->amplitude = 10.0f;
1677  p->octaves = 4;
1678  p->angle = DEG2RADF(45.0f);
1679  break;
1680  }
1683  p->frequency = 10.0f;
1684  p->amplitude = 10.0f;
1685  p->octaves = 4;
1686  p->angle = DEG2RADF(45.0f);
1687  break;
1688  }
1692  p->backbone_length = 10.0f;
1693  break;
1694  }
1695  case LS_MODIFIER_TIP_REMOVER: {
1697  p->tip_length = 10.0f;
1698  break;
1699  }
1703  p->error = 10.0f;
1704  break;
1705  }
1708  p->offset = 0.0f;
1709  break;
1710  }
1711  case LS_MODIFIER_BLUEPRINT: {
1714  p->rounds = 1;
1715  p->backbone_length = 10.0f;
1716  p->random_radius = 3;
1717  p->random_center = 5;
1718  p->random_backbone = 5;
1719  break;
1720  }
1721  case LS_MODIFIER_2D_OFFSET: {
1723  p->start = 0.0f;
1724  p->end = 0.0f;
1725  p->x = 0.0f;
1726  p->y = 0.0f;
1727  break;
1728  }
1729  case LS_MODIFIER_2D_TRANSFORM: {
1732  p->scale_x = 1.0f;
1733  p->scale_y = 1.0f;
1734  p->angle = DEG2RADF(0.0f);
1735  p->pivot_u = 0.5f;
1736  p->pivot_x = 0.0f;
1737  p->pivot_y = 0.0f;
1738  break;
1739  }
1742  p->tolerance = 0.1f;
1743  break;
1744  }
1745  default:
1746  return NULL; /* unknown modifier type */
1747  }
1749 
1750  return m;
1751 }
1752 
1754  const LineStyleModifier *m,
1755  const int UNUSED(flag))
1756 {
1757  LineStyleModifier *new_m;
1758 
1759  new_m = alloc_geometry_modifier(m->name, m->type);
1760  new_m->flags = m->flags;
1761 
1762  switch (m->type) {
1763  case LS_MODIFIER_SAMPLING: {
1766  q->sampling = p->sampling;
1767  break;
1768  }
1769  case LS_MODIFIER_BEZIER_CURVE: {
1772  q->error = p->error;
1773  break;
1774  }
1780  q->wavelength = p->wavelength;
1781  q->amplitude = p->amplitude;
1782  q->phase = p->phase;
1783  break;
1784  }
1788  q->amplitude = p->amplitude;
1789  q->scale = p->scale;
1790  q->octaves = p->octaves;
1791  q->flags = p->flags;
1792  break;
1793  }
1797  new_m;
1798  q->frequency = p->frequency;
1799  q->amplitude = p->amplitude;
1800  q->angle = p->angle;
1801  q->octaves = p->octaves;
1802  q->seed = p->seed;
1803  break;
1804  }
1808  new_m;
1809  q->frequency = p->frequency;
1810  q->amplitude = p->amplitude;
1811  q->angle = p->angle;
1812  q->octaves = p->octaves;
1813  q->seed = p->seed;
1814  break;
1815  }
1822  break;
1823  }
1824  case LS_MODIFIER_TIP_REMOVER: {
1827  q->tip_length = p->tip_length;
1828  break;
1829  }
1835  q->error = p->error;
1836  break;
1837  }
1841  q->offset = p->offset;
1842  break;
1843  }
1844  case LS_MODIFIER_BLUEPRINT: {
1847  q->flags = p->flags;
1848  q->rounds = p->rounds;
1850  q->random_radius = p->random_radius;
1851  q->random_center = p->random_center;
1853  break;
1854  }
1855  case LS_MODIFIER_2D_OFFSET: {
1858  q->start = p->start;
1859  q->end = p->end;
1860  q->x = p->x;
1861  q->y = p->y;
1862  break;
1863  }
1864  case LS_MODIFIER_2D_TRANSFORM: {
1867  q->pivot = p->pivot;
1868  q->scale_x = p->scale_x;
1869  q->scale_y = p->scale_y;
1870  q->angle = p->angle;
1871  q->pivot_u = p->pivot_u;
1872  q->pivot_x = p->pivot_x;
1873  q->pivot_y = p->pivot_y;
1874  break;
1875  }
1879  new_m;
1880  q->tolerance = p->tolerance;
1881  break;
1882  }
1883  default:
1884  return NULL; /* unknown modifier type */
1885  }
1887 
1888  return new_m;
1889 }
1890 
1892 {
1893  if (BLI_findindex(&linestyle->geometry_modifiers, m) == -1) {
1894  return -1;
1895  }
1897  return 0;
1898 }
1899 
1901  LineStyleModifier *modifier,
1902  int direction)
1903 {
1904  return BLI_listbase_link_move(&linestyle->color_modifiers, modifier, direction);
1905 }
1907  LineStyleModifier *modifier,
1908  int direction)
1909 {
1910  return BLI_listbase_link_move(&linestyle->alpha_modifiers, modifier, direction);
1911 }
1913  LineStyleModifier *modifier,
1914  int direction)
1915 {
1916  return BLI_listbase_link_move(&linestyle->thickness_modifiers, modifier, direction);
1917 }
1919  LineStyleModifier *modifier,
1920  int direction)
1921 {
1922  return BLI_listbase_link_move(&linestyle->geometry_modifiers, modifier, direction);
1923 }
1924 
1926 {
1927  LineStyleModifier *m;
1928  ColorBand *color_ramp;
1929  LinkData *link;
1930 
1931  BLI_listbase_clear(listbase);
1932 
1933  for (m = (LineStyleModifier *)linestyle->color_modifiers.first; m; m = m->next) {
1934  switch (m->type) {
1936  color_ramp = ((LineStyleColorModifier_AlongStroke *)m)->color_ramp;
1937  break;
1939  color_ramp = ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp;
1940  break;
1942  color_ramp = ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp;
1943  break;
1944  case LS_MODIFIER_MATERIAL:
1945  color_ramp = ((LineStyleColorModifier_Material *)m)->color_ramp;
1946  break;
1947  default:
1948  continue;
1949  }
1950  link = (LinkData *)MEM_callocN(sizeof(LinkData), "link to color ramp");
1951  link->data = color_ramp;
1952  BLI_addtail(listbase, link);
1953  }
1954 }
1955 
1957 {
1958  LineStyleModifier *m;
1959  bool found = false;
1960 
1961  for (m = (LineStyleModifier *)linestyle->color_modifiers.first; m; m = m->next) {
1962  switch (m->type) {
1964  if (color_ramp == ((LineStyleColorModifier_AlongStroke *)m)->color_ramp) {
1965  found = true;
1966  }
1967  break;
1969  if (color_ramp == ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp) {
1970  found = true;
1971  }
1972  break;
1974  if (color_ramp == ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp) {
1975  found = true;
1976  }
1977  break;
1978  case LS_MODIFIER_MATERIAL:
1979  if (color_ramp == ((LineStyleColorModifier_Material *)m)->color_ramp) {
1980  found = true;
1981  }
1982  break;
1983  case LS_MODIFIER_TANGENT:
1984  if (color_ramp == ((LineStyleColorModifier_Tangent *)m)->color_ramp) {
1985  found = true;
1986  }
1987  break;
1988  case LS_MODIFIER_NOISE:
1989  if (color_ramp == ((LineStyleColorModifier_Noise *)m)->color_ramp) {
1990  found = true;
1991  }
1992  break;
1994  if (color_ramp == ((LineStyleColorModifier_CreaseAngle *)m)->color_ramp) {
1995  found = true;
1996  }
1997  break;
1999  if (color_ramp == ((LineStyleColorModifier_Curvature_3D *)m)->color_ramp) {
2000  found = true;
2001  }
2002  break;
2003  }
2004 
2005  if (found) {
2006  char name_esc[sizeof(m->name) * 2];
2007  BLI_str_escape(name_esc, m->name, sizeof(name_esc));
2008  return BLI_sprintfN("color_modifiers[\"%s\"].color_ramp", name_esc);
2009  }
2010  }
2011  printf("BKE_linestyle_path_to_color_ramp: No color ramps correspond to the given pointer.\n");
2012  return NULL;
2013 }
2014 
2015 bool BKE_linestyle_use_textures(FreestyleLineStyle *linestyle, const bool use_shading_nodes)
2016 {
2017  if (use_shading_nodes) {
2019  bNode *node;
2020 
2021  for (node = linestyle->nodetree->nodes.first; node; node = node->next) {
2022  if (node->typeinfo->nclass == NODE_CLASS_TEXTURE) {
2023  return true;
2024  }
2025  }
2026  }
2027  }
2028  else {
2029  if (linestyle && (linestyle->flag & LS_TEXTURE)) {
2030  return (linestyle->mtex[0] != NULL);
2031  }
2032  }
2033  return false;
2034 }
2035 
2037 {
2038  bNode *uv_along_stroke, *input_texture, *output_linestyle;
2039  bNodeSocket *fromsock, *tosock;
2040  bNodeTree *ntree;
2041 
2043 
2044  ntree = ntreeAddTree(NULL, "stroke_shader", "ShaderNodeTree");
2045 
2047 
2048  uv_along_stroke = nodeAddStaticNode(C, ntree, SH_NODE_UVALONGSTROKE);
2049  uv_along_stroke->locx = 0.0f;
2050  uv_along_stroke->locy = 300.0f;
2051  uv_along_stroke->custom1 = 0; /* use_tips */
2052 
2053  input_texture = nodeAddStaticNode(C, ntree, SH_NODE_TEX_IMAGE);
2054  input_texture->locx = 200.0f;
2055  input_texture->locy = 300.0f;
2056 
2057  output_linestyle = nodeAddStaticNode(C, ntree, SH_NODE_OUTPUT_LINESTYLE);
2058  output_linestyle->locx = 400.0f;
2059  output_linestyle->locy = 300.0f;
2060  output_linestyle->custom1 = MA_RAMP_BLEND;
2061  output_linestyle->custom2 = 0; /* use_clamp */
2062 
2063  nodeSetActive(ntree, input_texture);
2064 
2065  fromsock = BLI_findlink(&uv_along_stroke->outputs, 0); /* UV */
2066  tosock = BLI_findlink(&input_texture->inputs, 0); /* UV */
2067  nodeAddLink(ntree, uv_along_stroke, fromsock, input_texture, tosock);
2068 
2069  fromsock = BLI_findlink(&input_texture->outputs, 0); /* Color */
2070  tosock = BLI_findlink(&output_linestyle->inputs, 0); /* Color */
2071  nodeAddLink(ntree, input_texture, fromsock, output_linestyle, tosock);
2072 
2074 }
void BKE_animdata_blend_read_data(struct BlendDataReader *reader, struct AnimData *adt)
Definition: anim_data.c:1443
void BKE_animdata_blend_write(struct BlendWriter *writer, struct AnimData *adt)
Definition: anim_data.c:1421
struct ColorBand * BKE_colorband_add(bool rangetype)
Definition: colorband.c:296
struct CurveMapping * BKE_curvemapping_copy(const struct CurveMapping *cumap)
void BKE_curvemapping_blend_read(struct BlendDataReader *reader, struct CurveMapping *cumap)
Definition: colortools.c:1300
void BKE_curvemapping_blend_write(struct BlendWriter *writer, const struct CurveMapping *cumap)
void BKE_curvemapping_free(struct CurveMapping *cumap)
Definition: colortools.c:103
struct CurveMapping * BKE_curvemapping_add(int tot, float minx, float miny, float maxx, float maxy)
Definition: colortools.c:72
struct Main * CTX_data_main(const bContext *C)
Definition: context.c:1074
struct FreestyleLineSet * BKE_freestyle_lineset_get_active(struct FreestyleConfig *config)
Definition: freestyle.c:213
@ IDTYPE_FLAGS_APPEND_IS_REUSABLE
Definition: BKE_idtype.h:39
@ LIB_ID_CREATE_NO_ALLOCATE
Definition: BKE_lib_id.h:130
@ LIB_ID_CREATE_NO_USER_REFCOUNT
Definition: BKE_lib_id.h:126
struct ID * BKE_id_copy_ex(struct Main *bmain, const struct ID *id, struct ID **r_newid, int flag)
void * BKE_libblock_alloc(struct Main *bmain, short type, const char *name, int flag) ATTR_WARN_UNUSED_RESULT
Definition: lib_id.c:1050
void id_us_plus(struct ID *id)
Definition: lib_id.c:305
void BKE_id_blend_write(struct BlendWriter *writer, struct ID *id)
Definition: lib_id.c:2008
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER(_data, _id_super, _cb_flag)
#define BKE_LIB_FOREACHID_PROCESS_FUNCTION_CALL(_data, _func_call)
void BKE_library_foreach_ID_embedded(struct LibraryForeachIDData *data, struct ID **id_pp)
Definition: lib_query.c:147
@ IDWALK_CB_NOP
Definition: BKE_lib_query.h:33
Blender kernel freestyle line style functionality.
void ntreeBlendWrite(struct BlendWriter *writer, struct bNodeTree *ntree)
Definition: node.cc:519
#define SH_NODE_UVALONGSTROKE
Definition: BKE_node.h:1162
void ntreeFreeEmbeddedTree(struct bNodeTree *ntree)
Definition: node.cc:3112
struct bNodeLink * nodeAddLink(struct bNodeTree *ntree, struct bNode *fromnode, struct bNodeSocket *fromsock, struct bNode *tonode, struct bNodeSocket *tosock)
Definition: node.cc:2296
struct bNodeTree * ntreeAddTree(struct Main *bmain, const char *name, const char *idname)
Definition: node.cc:2674
struct bNode * nodeAddStaticNode(const struct bContext *C, struct bNodeTree *ntree, int type)
Definition: node.cc:2151
#define NODE_CLASS_TEXTURE
Definition: BKE_node.h:355
void nodeSetActive(struct bNodeTree *ntree, struct bNode *node)
Definition: node.cc:3644
#define SH_NODE_OUTPUT_LINESTYLE
Definition: BKE_node.h:1161
void BKE_ntree_update_main_tree(struct Main *bmain, struct bNodeTree *ntree, struct NodeTreeUpdateExtraParams *params)
void BKE_texture_mtex_foreach_id(struct LibraryForeachIDData *data, struct MTex *mtex)
Definition: texture.c:221
#define BLI_assert(a)
Definition: BLI_assert.h:46
#define LISTBASE_FOREACH(type, var, list)
Definition: BLI_listbase.h:336
void BLI_freelinkN(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:239
BLI_INLINE void BLI_listbase_clear(struct ListBase *lb)
Definition: BLI_listbase.h:273
void BLI_addtail(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:80
void void void bool BLI_listbase_link_move(ListBase *listbase, void *vlink, int step) ATTR_NONNULL()
Definition: listbase.c:405
int BLI_findindex(const struct ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void * BLI_findlink(const struct ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
#define DEG2RADF(_deg)
size_t size_t char * BLI_sprintfN(const char *__restrict format,...) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC ATTR_PRINTF_FORMAT(1
char * BLI_strncpy(char *__restrict dst, const char *__restrict src, size_t maxncpy) ATTR_NONNULL()
Definition: string.c:64
size_t size_t char size_t BLI_str_escape(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL()
Definition: string.c:250
bool BLI_uniquename(struct ListBase *list, void *vlink, const char *defname, char delim, int name_offset, size_t name_len)
Definition: string_utils.c:309
#define UNUSED(x)
#define UNLIKELY(x)
#define MEMCMP_STRUCT_AFTER_IS_ZERO(struct_var, member)
#define MEMCPY_STRUCT_AFTER(struct_dst, struct_src, member)
#define BLO_read_data_address(reader, ptr_p)
#define BLO_write_id_struct(writer, struct_name, id_address, id)
#define BLO_write_struct(writer, struct_name, data_ptr)
void BLO_read_list(BlendDataReader *reader, struct ListBase *list)
Definition: readfile.c:5172
#define BLO_read_id_address(reader, lib, id_ptr_p)
#define BLO_expand(expander, id)
void BLO_write_struct_by_id(BlendWriter *writer, int struct_id, const void *data_ptr)
Definition: writefile.c:1512
#define BLT_I18NCONTEXT_ID_FREESTYLELINESTYLE
@ INDEX_ID_LS
Definition: DNA_ID.h:1013
#define FILTER_ID_LS
Definition: DNA_ID.h:908
@ ID_LS
Definition: DNA_ID_enums.h:75
#define DNA_struct_default_get(struct_name)
Definition: DNA_defaults.h:29
struct LineStyleColorModifier_Curvature_3D LineStyleColorModifier_Curvature_3D
struct LineStyleGeometryModifier_SinusDisplacement LineStyleGeometryModifier_SinusDisplacement
struct FreestyleLineStyle FreestyleLineStyle
struct LineStyleThicknessModifier_Curvature_3D LineStyleThicknessModifier_Curvature_3D
#define LS_MODIFIER_PERLIN_NOISE_1D
#define LS_THICKNESS_ASYMMETRIC
struct LineStyleThicknessModifier_CreaseAngle LineStyleThicknessModifier_CreaseAngle
struct LineStyleGeometryModifier_Simplification LineStyleGeometryModifier_Simplification
struct LineStyleThicknessModifier_Noise LineStyleThicknessModifier_Noise
struct LineStyleColorModifier_DistanceFromCamera LineStyleColorModifier_DistanceFromCamera
#define LS_MODIFIER_ENABLED
struct LineStyleGeometryModifier_2DOffset LineStyleGeometryModifier_2DOffset
struct LineStyleAlphaModifier_CreaseAngle LineStyleAlphaModifier_CreaseAngle
struct LineStyleAlphaModifier_DistanceFromCamera LineStyleAlphaModifier_DistanceFromCamera
#define LS_VALUE_BLEND
struct LineStyleColorModifier_AlongStroke LineStyleColorModifier_AlongStroke
#define LS_MODIFIER_SPATIAL_NOISE_SMOOTH
struct LineStyleColorModifier_Material LineStyleColorModifier_Material
#define LS_MODIFIER_2D_TRANSFORM_PIVOT_CENTER
struct LineStyleThicknessModifier_DistanceFromCamera LineStyleThicknessModifier_DistanceFromCamera
#define LS_MODIFIER_TIP_REMOVER
struct LineStyleGeometryModifier_2DTransform LineStyleGeometryModifier_2DTransform
struct LineStyleGeometryModifier_PerlinNoise2D LineStyleGeometryModifier_PerlinNoise2D
#define LS_MODIFIER_DISTANCE_FROM_CAMERA
struct LineStyleThicknessModifier_AlongStroke LineStyleThicknessModifier_AlongStroke
struct LineStyleGeometryModifier_GuidingLines LineStyleGeometryModifier_GuidingLines
struct LineStyleGeometryModifier_SpatialNoise LineStyleGeometryModifier_SpatialNoise
#define LS_MODIFIER_SPATIAL_NOISE_PURERANDOM
struct LineStyleThicknessModifier_DistanceFromObject LineStyleThicknessModifier_DistanceFromObject
struct LineStyleThicknessModifier_Material LineStyleThicknessModifier_Material
struct LineStyleColorModifier_Tangent LineStyleColorModifier_Tangent
#define LS_MODIFIER_TANGENT
#define LS_MODIFIER_CREASE_ANGLE
#define LS_MODIFIER_BACKBONE_STRETCHER
struct LineStyleColorModifier_CreaseAngle LineStyleColorModifier_CreaseAngle
#define LS_MODIFIER_MATERIAL_LINE_A
struct LineStyleAlphaModifier_AlongStroke LineStyleAlphaModifier_AlongStroke
struct LineStyleAlphaModifier_Tangent LineStyleAlphaModifier_Tangent
#define LS_MODIFIER_SAMPLING
#define LS_MODIFIER_2D_OFFSET
#define LS_MODIFIER_DISTANCE_FROM_OBJECT
struct LineStyleColorModifier_Noise LineStyleColorModifier_Noise
#define LS_MODIFIER_NOISE
#define LS_MODIFIER_ALONG_STROKE
struct LineStyleGeometryModifier_BackboneStretcher LineStyleGeometryModifier_BackboneStretcher
struct LineStyleGeometryModifier_PerlinNoise1D LineStyleGeometryModifier_PerlinNoise1D
#define LS_MODIFIER_NUM
#define LS_TEXTURE
struct LineStyleAlphaModifier_Curvature_3D LineStyleAlphaModifier_Curvature_3D
#define LS_MODIFIER_POLYGONIZATION
#define LS_MODIFIER_CURVATURE_3D
#define LS_MODIFIER_MATERIAL_LINE
#define LS_MODIFIER_CALLIGRAPHY
#define LS_MODIFIER_BLUEPRINT
struct LineStyleColorModifier_DistanceFromObject LineStyleColorModifier_DistanceFromObject
#define LS_MODIFIER_BLUEPRINT_CIRCLES
struct LineStyleThicknessModifier_Tangent LineStyleThicknessModifier_Tangent
struct LineStyleGeometryModifier_Blueprint LineStyleGeometryModifier_Blueprint
#define LS_MODIFIER_2D_TRANSFORM
#define LS_MODIFIER_SPATIAL_NOISE
#define LS_MODIFIER_BEZIER_CURVE
#define LS_MODIFIER_PERLIN_NOISE_2D
#define LS_MODIFIER_SIMPLIFICATION
struct LineStyleAlphaModifier_Noise LineStyleAlphaModifier_Noise
#define LS_MODIFIER_SINUS_DISPLACEMENT
#define LS_MODIFIER_EXPANDED
struct LineStyleAlphaModifier_Material LineStyleAlphaModifier_Material
struct LineStyleAlphaModifier_DistanceFromObject LineStyleAlphaModifier_DistanceFromObject
struct LineStyleGeometryModifier_Sampling LineStyleGeometryModifier_Sampling
struct LineStyleGeometryModifier_Polygonalization LineStyleGeometryModifier_Polygonalization
#define LS_MODIFIER_MATERIAL
struct LineStyleThicknessModifier_Calligraphy LineStyleThicknessModifier_Calligraphy
#define LS_MODIFIER_GUIDING_LINES
struct LineStyleGeometryModifier_TipRemover LineStyleGeometryModifier_TipRemover
struct LineStyleGeometryModifier_BezierCurve LineStyleGeometryModifier_BezierCurve
#define MA_RAMP_BLEND
Object is a sort of wrapper for general info.
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
Read Guarded memory(de)allocation.
#define MEM_SAFE_FREE(v)
static void init_data(ModifierData *md)
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block SH_NODE_TEX_IMAGE
#define C
Definition: RandGen.cpp:25
#define MAX_MTEX
Definition: Stroke.h:31
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
Definition: btDbvt.cpp:52
OperationNode * node
Curve curve
FreestyleLineStyle linestyle
bNodeTree * ntree
static void direct_link_linestyle_alpha_modifier(BlendDataReader *reader, LineStyleModifier *modifier)
Definition: linestyle.c:519
static void linestyle_free_data(ID *id)
Definition: linestyle.c:107
void BKE_linestyle_default_shader(const bContext *C, FreestyleLineStyle *linestyle)
Definition: linestyle.c:2036
bool BKE_linestyle_use_textures(FreestyleLineStyle *linestyle, const bool use_shading_nodes)
Definition: linestyle.c:2015
static void linestyle_init_data(ID *id)
Definition: linestyle.c:42
FreestyleLineStyle * BKE_linestyle_active_from_view_layer(ViewLayer *view_layer)
Definition: linestyle.c:806
void BKE_linestyle_modifier_list_color_ramps(FreestyleLineStyle *linestyle, ListBase *listbase)
Definition: linestyle.c:1925
LineStyleModifier * BKE_linestyle_geometry_modifier_add(FreestyleLineStyle *linestyle, const char *name, int type)
Definition: linestyle.c:1638
static void linestyle_blend_read_lib(BlendLibReader *reader, ID *id)
Definition: linestyle.c:662
bool BKE_linestyle_thickness_modifier_move(FreestyleLineStyle *linestyle, LineStyleModifier *modifier, int direction)
Definition: linestyle.c:1912
static void direct_link_linestyle_color_modifier(BlendDataReader *reader, LineStyleModifier *modifier)
Definition: linestyle.c:470
void BKE_linestyle_init(FreestyleLineStyle *linestyle)
Definition: linestyle.c:790
static void write_linestyle_geometry_modifiers(BlendWriter *writer, ListBase *modifiers)
Definition: linestyle.c:388
int BKE_linestyle_thickness_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *m)
Definition: linestyle.c:1550
LineStyleModifier * BKE_linestyle_color_modifier_copy(FreestyleLineStyle *linestyle, const LineStyleModifier *m, const int flag)
Definition: linestyle.c:930
bool BKE_linestyle_color_modifier_move(FreestyleLineStyle *linestyle, LineStyleModifier *modifier, int direction)
Definition: linestyle.c:1900
static void direct_link_linestyle_geometry_modifier(BlendDataReader *UNUSED(reader), LineStyleModifier *UNUSED(modifier))
Definition: linestyle.c:630
LineStyleModifier * BKE_linestyle_thickness_modifier_add(FreestyleLineStyle *linestyle, const char *name, int type)
Definition: linestyle.c:1335
static void write_linestyle_alpha_modifiers(BlendWriter *writer, ListBase *modifiers)
Definition: linestyle.c:251
static LineStyleModifier * alloc_geometry_modifier(const char *name, int type)
Definition: linestyle.c:1584
LineStyleModifier * BKE_linestyle_color_modifier_add(FreestyleLineStyle *linestyle, const char *name, int type)
Definition: linestyle.c:872
static void direct_link_linestyle_thickness_modifier(BlendDataReader *reader, LineStyleModifier *modifier)
Definition: linestyle.c:576
static LineStyleModifier * alloc_thickness_modifier(const char *name, int type)
Definition: linestyle.c:1296
static void write_linestyle_thickness_modifiers(BlendWriter *writer, ListBase *modifiers)
Definition: linestyle.c:319
LineStyleModifier * BKE_linestyle_geometry_modifier_copy(FreestyleLineStyle *linestyle, const LineStyleModifier *m, const int UNUSED(flag))
Definition: linestyle.c:1753
static LineStyleModifier * alloc_alpha_modifier(const char *name, int type)
Definition: linestyle.c:1057
static void write_linestyle_color_modifiers(BlendWriter *writer, ListBase *modifiers)
Definition: linestyle.c:182
int BKE_linestyle_color_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *m)
Definition: linestyle.c:1022
static void linestyle_blend_read_data(BlendDataReader *reader, ID *id)
Definition: linestyle.c:635
static void linestyle_blend_write(BlendWriter *writer, ID *id, const void *id_address)
Definition: linestyle.c:444
LineStyleModifier * BKE_linestyle_alpha_modifier_copy(FreestyleLineStyle *linestyle, const LineStyleModifier *m, const int UNUSED(flag))
Definition: linestyle.c:1165
bool BKE_linestyle_alpha_modifier_move(FreestyleLineStyle *linestyle, LineStyleModifier *modifier, int direction)
Definition: linestyle.c:1906
FreestyleLineStyle * BKE_linestyle_new(struct Main *bmain, const char *name)
Definition: linestyle.c:795
bool BKE_linestyle_geometry_modifier_move(FreestyleLineStyle *linestyle, LineStyleModifier *modifier, int direction)
Definition: linestyle.c:1918
LineStyleModifier * BKE_linestyle_thickness_modifier_copy(FreestyleLineStyle *linestyle, const LineStyleModifier *m, const int flag)
Definition: linestyle.c:1429
static void linestyle_copy_data(Main *bmain, ID *id_dst, const ID *id_src, const int flag)
Definition: linestyle.c:53
LineStyleModifier * BKE_linestyle_alpha_modifier_add(FreestyleLineStyle *linestyle, const char *name, int type)
Definition: linestyle.c:1092
int BKE_linestyle_alpha_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *m)
Definition: linestyle.c:1261
static LineStyleModifier * alloc_color_modifier(const char *name, int type)
Definition: linestyle.c:836
static void linestyle_foreach_id(ID *id, LibraryForeachIDData *data)
Definition: linestyle.c:137
static LineStyleModifier * new_modifier(const char *name, int type, size_t size)
Definition: linestyle.c:813
static const char * modifier_name[LS_MODIFIER_NUM]
Definition: linestyle.c:763
int BKE_linestyle_geometry_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *m)
Definition: linestyle.c:1891
static void add_to_modifier_list(ListBase *lb, LineStyleModifier *m)
Definition: linestyle.c:829
char * BKE_linestyle_path_to_color_ramp(FreestyleLineStyle *linestyle, ColorBand *color_ramp)
Definition: linestyle.c:1956
static void linestyle_blend_read_expand(BlendExpander *expander, ID *id)
Definition: linestyle.c:705
IDTypeInfo IDType_ID_LS
Definition: linestyle.c:733
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
void *(* MEM_dupallocN)(const void *vmemh)
Definition: mallocn.c:28
void *(* MEM_callocN)(size_t len, const char *str)
Definition: mallocn.c:31
void *(* MEM_mallocN)(size_t len, const char *str)
Definition: mallocn.c:33
static unsigned a[3]
Definition: RandGen.cpp:78
struct FreestyleLineStyle * linestyle
struct AnimData * adt
struct bNodeTree * nodetree
struct MTex * mtex[18]
short id_code
Definition: BKE_idtype.h:114
Definition: DNA_ID.h:368
struct Library * lib
Definition: DNA_ID.h:372
struct LineStyleModifier * next
void * data
Definition: DNA_listBase.h:26
void * first
Definition: DNA_listBase.h:31
struct Object * object
struct Tex * tex
Definition: BKE_main.h:121
struct FreestyleConfig freestyle_config
ListBase nodes
short custom1
float locy
ListBase inputs
float locx
short custom2
ListBase outputs