Blender V5.3
linestyle.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2010 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <algorithm>
10#include <cstdio>
11#include <cstdlib>
12#include <cstring>
13#include <optional>
14
15#include <fmt/format.h>
16
17#include "MEM_guardedalloc.h"
18
19#include "DNA_layer_types.h"
20#include "DNA_material_types.h" /* for ramp blend */
21#include "DNA_object_types.h"
22#include "DNA_sdna_type_ids.hh"
23#include "DNA_texture_types.h"
24
25#include "BLI_listbase.hh"
27#include "BLI_string.hh"
28#include "BLI_string_utf8.hh"
29#include "BLI_string_utils.hh"
30#include "BLI_utildefines.hh"
31
32#include "BLT_translation.hh"
33
34#include "BKE_colorband.hh"
35#include "BKE_colortools.hh"
36#include "BKE_context.hh"
37#include "BKE_freestyle.h"
38#include "BKE_idtype.hh"
39#include "BKE_lib_id.hh"
40#include "BKE_lib_query.hh"
41#include "BKE_linestyle.h"
42#include "BKE_node.hh"
45#include "BKE_texture.h"
46
47#include "BLO_read_write.hh"
48
49namespace blender {
50
52
53static void linestyle_init_data(ID *id)
54{
55 FreestyleLineStyle *linestyle = id_cast<FreestyleLineStyle *>(id);
56 INIT_DEFAULT_STRUCT_AFTER(linestyle, id);
57
59}
60
61static void linestyle_copy_data(Main *bmain,
62 std::optional<Library *> owner_library,
63 ID *id_dst,
64 const ID *id_src,
65 const int flag)
66{
67 FreestyleLineStyle *linestyle_dst = id_cast<FreestyleLineStyle *>(id_dst);
68 const FreestyleLineStyle *linestyle_src = id_cast<const FreestyleLineStyle *>(id_src);
69
70 /* Never handle user-count here for own sub-data. */
71 const int flag_subdata = flag | LIB_ID_CREATE_NO_USER_REFCOUNT;
72 /* Always need allocation of the embedded ID data. */
73 const int flag_embedded_id_data = flag_subdata & ~LIB_ID_CREATE_NO_ALLOCATE;
74
75 for (int a = 0; a < MAX_MTEX; a++) {
76 if (linestyle_src->mtex[a]) {
77 linestyle_dst->mtex[a] = MEM_new<MTex>(__func__);
78 *linestyle_dst->mtex[a] = dna::shallow_copy(*linestyle_src->mtex[a]);
79 }
80 }
81
82 if (linestyle_src->nodetree) {
84 owner_library,
85 &linestyle_src->nodetree->id,
86 &linestyle_dst->id,
87 reinterpret_cast<ID **>(&linestyle_dst->nodetree),
88 flag_embedded_id_data);
89 }
90
91 linestyle_dst->color_modifiers.clear_no_delete();
92 for (LineStyleModifier &linestyle_modifier : linestyle_src->color_modifiers) {
93 BKE_linestyle_color_modifier_copy(linestyle_dst, &linestyle_modifier, flag_subdata);
94 }
95
96 linestyle_dst->alpha_modifiers.clear_no_delete();
97 for (LineStyleModifier &linestyle_modifier : linestyle_src->alpha_modifiers) {
98 BKE_linestyle_alpha_modifier_copy(linestyle_dst, &linestyle_modifier, flag_subdata);
99 }
100
101 linestyle_dst->thickness_modifiers.clear_no_delete();
102 for (LineStyleModifier &linestyle_modifier : linestyle_src->thickness_modifiers) {
103 BKE_linestyle_thickness_modifier_copy(linestyle_dst, &linestyle_modifier, flag_subdata);
104 }
105
106 linestyle_dst->geometry_modifiers.clear_no_delete();
107 for (LineStyleModifier &linestyle_modifier : linestyle_src->geometry_modifiers) {
108 BKE_linestyle_geometry_modifier_copy(linestyle_dst, &linestyle_modifier, flag_subdata);
109 }
110}
111
112static void linestyle_free_data(ID *id)
113{
114 FreestyleLineStyle *linestyle = id_cast<FreestyleLineStyle *>(id);
115 LineStyleModifier *linestyle_modifier;
116
117 for (int material_slot_index = 0; material_slot_index < MAX_MTEX; material_slot_index++) {
118 MEM_SAFE_DELETE(linestyle->mtex[material_slot_index]);
119 }
120
121 /* is no lib link block, but linestyle extension */
122 if (linestyle->nodetree) {
124 MEM_delete(linestyle->nodetree);
125 linestyle->nodetree = nullptr;
126 }
127
128 while ((linestyle_modifier = linestyle->color_modifiers.first())) {
129 BKE_linestyle_color_modifier_remove(linestyle, linestyle_modifier);
130 }
131 while ((linestyle_modifier = linestyle->alpha_modifiers.first())) {
132 BKE_linestyle_alpha_modifier_remove(linestyle, linestyle_modifier);
133 }
134 while ((linestyle_modifier = linestyle->thickness_modifiers.first())) {
135 BKE_linestyle_thickness_modifier_remove(linestyle, linestyle_modifier);
136 }
137 while ((linestyle_modifier = linestyle->geometry_modifiers.first())) {
138 BKE_linestyle_geometry_modifier_remove(linestyle, linestyle_modifier);
139 }
140}
141
143{
144 FreestyleLineStyle *linestyle = id_cast<FreestyleLineStyle *>(id);
145
146 for (int i = 0; i < MAX_MTEX; i++) {
147 if (linestyle->mtex[i]) {
149 data, BKE_texture_mtex_foreach_id(data, linestyle->mtex[i]));
150 }
151 }
152 if (linestyle->nodetree) {
153 /* nodetree **are owned by IDs**, treat them as mere sub-data and not real ID! */
156 }
157
158 for (LineStyleModifier &lsm : linestyle->color_modifiers) {
161 reinterpret_cast<LineStyleColorModifier_DistanceFromObject *>(&lsm);
163 }
164 }
165 for (LineStyleModifier &lsm : linestyle->alpha_modifiers) {
168 reinterpret_cast<LineStyleAlphaModifier_DistanceFromObject *>(&lsm);
170 }
171 }
172 for (LineStyleModifier &lsm : linestyle->thickness_modifiers) {
175 reinterpret_cast<LineStyleThicknessModifier_DistanceFromObject *>(&lsm);
177 }
178 }
179}
180
183{
184 FreestyleLineStyle *linestyle = id_cast<FreestyleLineStyle *>(id);
185
186 fn.single(&linestyle->r);
187}
188
190 ListBaseT<LineStyleModifier> *modifiers)
191{
192 for (LineStyleModifier &m : *modifiers) {
193 int struct_nr;
194 switch (m.type) {
197 break;
200 break;
203 break;
206 break;
209 break;
212 break;
215 break;
218 break;
219 default:
220 struct_nr = sdna_struct_id_get<LineStyleModifier>(); /* this should not happen */
221 }
222 writer->write_struct_by_id(struct_nr, &m);
223 }
224 for (LineStyleModifier &m : *modifiers) {
225 switch (m.type) {
227 writer->write_struct(
228 (reinterpret_cast<LineStyleColorModifier_AlongStroke *>(&m))->color_ramp);
229 break;
231 writer->write_struct(
232 (reinterpret_cast<LineStyleColorModifier_DistanceFromCamera *>(&m))->color_ramp);
233 break;
235 writer->write_struct(
236 (reinterpret_cast<LineStyleColorModifier_DistanceFromObject *>(&m))->color_ramp);
237 break;
239 writer->write_struct(
240 (reinterpret_cast<LineStyleColorModifier_Material *>(&m))->color_ramp);
241 break;
243 writer->write_struct((reinterpret_cast<LineStyleColorModifier_Tangent *>(&m))->color_ramp);
244 break;
246 writer->write_struct((reinterpret_cast<LineStyleColorModifier_Noise *>(&m))->color_ramp);
247 break;
249 writer->write_struct(
250 (reinterpret_cast<LineStyleColorModifier_CreaseAngle *>(&m))->color_ramp);
251 break;
253 writer->write_struct(
254 (reinterpret_cast<LineStyleColorModifier_Curvature_3D *>(&m))->color_ramp);
255 break;
256 default:
257 break;
258 }
259 }
260}
261
263 ListBaseT<LineStyleModifier> *modifiers)
264{
265 for (LineStyleModifier &m : *modifiers) {
266 int struct_nr;
267 switch (m.type) {
270 break;
273 break;
276 break;
279 break;
282 break;
285 break;
288 break;
291 break;
292 default:
293 struct_nr = sdna_struct_id_get<LineStyleModifier>(); /* this should not happen */
294 }
295 writer->write_struct_by_id(struct_nr, &m);
296 }
297 for (LineStyleModifier &m : *modifiers) {
298 switch (m.type) {
301 writer, (reinterpret_cast<LineStyleAlphaModifier_AlongStroke *>(&m))->curve);
302 break;
305 writer, (reinterpret_cast<LineStyleAlphaModifier_DistanceFromCamera *>(&m))->curve);
306 break;
309 writer, (reinterpret_cast<LineStyleAlphaModifier_DistanceFromObject *>(&m))->curve);
310 break;
313 writer, (reinterpret_cast<LineStyleAlphaModifier_Material *>(&m))->curve);
314 break;
317 writer, (reinterpret_cast<LineStyleAlphaModifier_Tangent *>(&m))->curve);
318 break;
321 writer, (reinterpret_cast<LineStyleAlphaModifier_Noise *>(&m))->curve);
322 break;
325 writer, (reinterpret_cast<LineStyleAlphaModifier_CreaseAngle *>(&m))->curve);
326 break;
329 writer, (reinterpret_cast<LineStyleAlphaModifier_Curvature_3D *>(&m))->curve);
330 break;
331 default:
332 break;
333 }
334 }
335}
336
338 ListBaseT<LineStyleModifier> *modifiers)
339{
340 for (LineStyleModifier &m : *modifiers) {
341 int struct_nr;
342 switch (m.type) {
345 break;
348 break;
351 break;
354 break;
357 break;
360 break;
363 break;
366 break;
369 break;
370 default:
371 struct_nr = sdna_struct_id_get<LineStyleModifier>(); /* this should not happen */
372 }
373 writer->write_struct_by_id(struct_nr, &m);
374 }
375 for (LineStyleModifier &m : *modifiers) {
376 switch (m.type) {
379 writer, (reinterpret_cast<LineStyleThicknessModifier_AlongStroke *>(&m))->curve);
380 break;
383 writer,
384 (reinterpret_cast<LineStyleThicknessModifier_DistanceFromCamera *>(&m))->curve);
385 break;
388 writer,
389 (reinterpret_cast<LineStyleThicknessModifier_DistanceFromObject *>(&m))->curve);
390 break;
393 writer, (reinterpret_cast<LineStyleThicknessModifier_Material *>(&m))->curve);
394 break;
397 writer, (reinterpret_cast<LineStyleThicknessModifier_Tangent *>(&m))->curve);
398 break;
401 writer, (reinterpret_cast<LineStyleThicknessModifier_CreaseAngle *>(&m))->curve);
402 break;
405 writer, (reinterpret_cast<LineStyleThicknessModifier_Curvature_3D *>(&m))->curve);
406 break;
407 default:
408 break;
409 }
410 }
411}
412
414 ListBaseT<LineStyleModifier> *modifiers)
415{
416 for (LineStyleModifier &m : *modifiers) {
417 int struct_nr;
418 switch (m.type) {
421 break;
424 break;
427 break;
430 break;
433 break;
436 break;
439 break;
442 break;
445 break;
448 break;
451 break;
454 break;
457 break;
460 break;
461 default:
462 struct_nr = sdna_struct_id_get<LineStyleModifier>(); /* this should not happen */
463 }
464 writer->write_struct_by_id(struct_nr, &m);
465 }
466}
467
468static void linestyle_blend_write(BlendWriter *writer, ID *id, const void *id_address)
469{
470 FreestyleLineStyle *linestyle = id_cast<FreestyleLineStyle *>(id);
471
472 writer->write_id_struct(id_address, linestyle);
473 BKE_id_blend_write(writer, &linestyle->id);
474
479 for (int a = 0; a < MAX_MTEX; a++) {
480 if (linestyle->mtex[a]) {
481 writer->write_struct(linestyle->mtex[a]);
482 }
483 }
484 if (linestyle->nodetree) {
485 BLO_Write_IDBuffer temp_embedded_id_buffer{linestyle->nodetree->id, writer};
486 bNodeTree *temp_ntree = reinterpret_cast<bNodeTree *>(temp_embedded_id_buffer.get());
487 writer->write_embedded_id_struct(linestyle->nodetree, temp_ntree);
488 bke::node_tree_blend_write(writer, temp_ntree);
489 }
490}
491
494{
495 switch (modifier->type) {
498 reinterpret_cast<LineStyleColorModifier_AlongStroke *>(modifier);
500 break;
501 }
506 break;
507 }
512 break;
513 }
516 modifier);
518 break;
519 }
520 case LS_MODIFIER_TANGENT: {
522 modifier);
524 break;
525 }
526 case LS_MODIFIER_NOISE: {
529 break;
530 }
533 reinterpret_cast<LineStyleColorModifier_CreaseAngle *>(modifier);
535 break;
536 }
541 break;
542 }
543 default:
544 break;
545 }
546}
547
550{
551 switch (modifier->type) {
554 reinterpret_cast<LineStyleAlphaModifier_AlongStroke *>(modifier);
555 BLO_read_struct(reader, CurveMapping, &m->curve);
557 break;
558 }
562 BLO_read_struct(reader, CurveMapping, &m->curve);
564 break;
565 }
569 BLO_read_struct(reader, CurveMapping, &m->curve);
571 break;
572 }
575 modifier);
576 BLO_read_struct(reader, CurveMapping, &m->curve);
578 break;
579 }
580 case LS_MODIFIER_TANGENT: {
582 modifier);
583 BLO_read_struct(reader, CurveMapping, &m->curve);
585 break;
586 }
587 case LS_MODIFIER_NOISE: {
589 BLO_read_struct(reader, CurveMapping, &m->curve);
591 break;
592 }
595 reinterpret_cast<LineStyleAlphaModifier_CreaseAngle *>(modifier);
596 BLO_read_struct(reader, CurveMapping, &m->curve);
598 break;
599 }
603 BLO_read_struct(reader, CurveMapping, &m->curve);
605 break;
606 }
607 default:
608 break;
609 }
610}
611
614{
615 switch (modifier->type) {
619 BLO_read_struct(reader, CurveMapping, &m->curve);
621 break;
622 }
626 BLO_read_struct(reader, CurveMapping, &m->curve);
628 break;
629 }
633 BLO_read_struct(reader, CurveMapping, &m->curve);
635 break;
636 }
640 BLO_read_struct(reader, CurveMapping, &m->curve);
642 break;
643 }
644 case LS_MODIFIER_TANGENT: {
646 reinterpret_cast<LineStyleThicknessModifier_Tangent *>(modifier);
647 BLO_read_struct(reader, CurveMapping, &m->curve);
649 break;
650 }
654 BLO_read_struct(reader, CurveMapping, &m->curve);
656 break;
657 }
661 BLO_read_struct(reader, CurveMapping, &m->curve);
663 break;
664 }
665 default:
666 break;
667 }
668}
669
671 LineStyleModifier * /*modifier*/)
672{
673}
674
679
681 ListBaseT<LineStyleModifier> *modifiers,
683{
685 reader, modifiers, [&](const LineStyleModifier &modifier) {
686 return std::max(struct_size(modifier.type), sizeof(LineStyleModifier));
687 });
688}
689
691{
692 FreestyleLineStyle *linestyle = id_cast<FreestyleLineStyle *>(id);
693
695 for (LineStyleModifier &modifier : linestyle->color_modifiers) {
697 }
699 for (LineStyleModifier &modifier : linestyle->alpha_modifiers) {
701 }
706 }
708 for (LineStyleModifier &modifier : linestyle->geometry_modifiers) {
710 }
711 for (int a = 0; a < MAX_MTEX; a++) {
712 BLO_read_struct(reader, MTex, &linestyle->mtex[a]);
713 }
714}
715
717 .id_code = FreestyleLineStyle::id_type,
718 .id_filter = FILTER_ID_LS,
719 .dependencies_id_types = FILTER_ID_TE | FILTER_ID_OB,
720 .main_listbase_index = INDEX_ID_LS,
721 .struct_size = sizeof(FreestyleLineStyle),
722 .name = "FreestyleLineStyle",
723 .name_plural = N_("linestyles"),
724 .translation_context = BLT_I18NCONTEXT_ID_FREESTYLELINESTYLE,
726 .asset_type_info = nullptr,
727
728 .init_data = linestyle_init_data,
729 .copy_data = linestyle_copy_data,
730 .free_data = linestyle_free_data,
731 .make_local = nullptr,
732 .foreach_id = linestyle_foreach_id,
733 .foreach_cache = nullptr,
734 .foreach_path = nullptr,
735 .foreach_working_space_color = linestyle_foreach_working_space_color,
736 .foreach_asset_weak_reference = nullptr,
737 .owner_pointer_get = nullptr,
738
739 .blend_write = linestyle_blend_write,
740 .blend_read_data = linestyle_blend_read_data,
741 .blend_read_after_liblink = nullptr,
742
743 .blend_read_undo_preserve = nullptr,
744
745 .lib_override_apply_post = nullptr,
746};
747
748static const char *modifier_name[LS_MODIFIER_NUM] = {
749 nullptr, "Along Stroke", "Distance from Camera", "Distance from Object",
750 "Material", "Sampling", "Bézier Curve", "Sinus Displacement",
751 "Spatial Noise", "Perlin Noise 1D", "Perlin Noise 2D", "Backbone Stretcher",
752 "Tip Remover", "Calligraphy", "Polygonalization", "Guiding Lines",
753 "Blueprint", "2D Offset", "2D Transform", "Tangent",
754 "Noise", "Crease Angle", "Simplification", "Curvature 3D",
755};
756
758{
759 linestyle_init_data(&linestyle->id);
760}
761
762FreestyleLineStyle *BKE_linestyle_new(Main *bmain, const char *name)
763{
764 FreestyleLineStyle *linestyle;
765
766 linestyle = static_cast<FreestyleLineStyle *>(BKE_libblock_alloc(bmain, ID_LS, name, 0));
767
768 BKE_linestyle_init(linestyle);
769
770 return linestyle;
771}
772
774{
775 FreestyleConfig *config = &view_layer->freestyle_config;
777 return (lineset) ? lineset->linestyle : nullptr;
778}
779
780static LineStyleModifier *new_modifier(const char *name, eLineStyleModifier_Type type, size_t size)
781{
783
784 if (!name) {
785 name = modifier_name[type];
786 }
787 m = static_cast<LineStyleModifier *>(MEM_new_zeroed(size, "line style modifier"));
788 m->type = type;
789 STRNCPY_UTF8(m->name, DATA_(name));
790 m->influence = 1.0f;
792
793 return m;
794}
795
796static void add_to_modifier_list(ListBaseT<LineStyleModifier> *lb, LineStyleModifier *m)
797{
798 BLI_addtail(lb, static_cast<void *>(m));
800 lb, m, modifier_name[m->type], '.', offsetof(LineStyleModifier, name), sizeof(m->name));
801}
802
804{
805 switch (type) {
813 return sizeof(LineStyleColorModifier_Material);
815 return sizeof(LineStyleColorModifier_Tangent);
817 return sizeof(LineStyleColorModifier_Noise);
822 default:
823 return 0; /* unknown modifier type */
824 }
825}
826
828{
829 const size_t size = color_modifier_struct_size(type);
830 if (size == 0) {
831 return nullptr;
832 }
833 return new_modifier(name, type, size);
834}
835
837 const char *name,
839{
841
842 m = alloc_color_modifier(name, type);
843 if (m == nullptr) [[unlikely]] {
844 return nullptr;
845 }
847
848 switch (type) {
850 (reinterpret_cast<LineStyleColorModifier_AlongStroke *>(m))->color_ramp = BKE_colorband_add(
851 true);
852 break;
854 (reinterpret_cast<LineStyleColorModifier_DistanceFromCamera *>(m))->color_ramp =
855 BKE_colorband_add(true);
856 (reinterpret_cast<LineStyleColorModifier_DistanceFromCamera *>(m))->range_min = 0.0f;
857 (reinterpret_cast<LineStyleColorModifier_DistanceFromCamera *>(m))->range_max = 10000.0f;
858 break;
860 (reinterpret_cast<LineStyleColorModifier_DistanceFromObject *>(m))->target = nullptr;
861 (reinterpret_cast<LineStyleColorModifier_DistanceFromObject *>(m))->color_ramp =
862 BKE_colorband_add(true);
863 (reinterpret_cast<LineStyleColorModifier_DistanceFromObject *>(m))->range_min = 0.0f;
864 (reinterpret_cast<LineStyleColorModifier_DistanceFromObject *>(m))->range_max = 10000.0f;
865 break;
867 (reinterpret_cast<LineStyleColorModifier_Material *>(m))->color_ramp = BKE_colorband_add(
868 true);
869 (reinterpret_cast<LineStyleColorModifier_Material *>(m))->mat_attr =
871 break;
873 (reinterpret_cast<LineStyleColorModifier_Tangent *>(m))->color_ramp = BKE_colorband_add(
874 true);
875 break;
877 (reinterpret_cast<LineStyleColorModifier_Noise *>(m))->color_ramp = BKE_colorband_add(true);
878 (reinterpret_cast<LineStyleColorModifier_Noise *>(m))->amplitude = 10.0f;
879 (reinterpret_cast<LineStyleColorModifier_Noise *>(m))->period = 10.0f;
880 (reinterpret_cast<LineStyleColorModifier_Noise *>(m))->seed = 512;
881 break;
883 (reinterpret_cast<LineStyleColorModifier_CreaseAngle *>(m))->color_ramp = BKE_colorband_add(
884 true);
885 (reinterpret_cast<LineStyleColorModifier_CreaseAngle *>(m))->min_angle = 0.0f;
886 (reinterpret_cast<LineStyleColorModifier_CreaseAngle *>(m))->max_angle = DEG2RADF(180.0f);
887 break;
889 (reinterpret_cast<LineStyleColorModifier_Curvature_3D *>(m))->color_ramp = BKE_colorband_add(
890 true);
891 (reinterpret_cast<LineStyleColorModifier_Curvature_3D *>(m))->min_curvature = 0.0f;
892 (reinterpret_cast<LineStyleColorModifier_Curvature_3D *>(m))->max_curvature = 0.5f;
893 break;
894 default:
895 return nullptr; /* unknown modifier type */
896 }
898
899 return m;
900}
901
903 const LineStyleModifier *m,
904 const int flag)
905{
906 LineStyleModifier *new_m;
907
908 new_m = alloc_color_modifier(m->name, m->type);
909 if (new_m == nullptr) [[unlikely]] {
910 return nullptr;
911 }
912 new_m->influence = m->influence;
913 new_m->flags = m->flags;
914 new_m->blend = m->blend;
915
916 switch (m->type) {
919 reinterpret_cast<LineStyleColorModifier_AlongStroke *>(
920 const_cast<LineStyleModifier *>(m));
922 reinterpret_cast<LineStyleColorModifier_AlongStroke *>(new_m);
923 q->color_ramp = MEM_dupalloc(p->color_ramp);
924 break;
925 }
929 const_cast<LineStyleModifier *>(m));
931 reinterpret_cast<LineStyleColorModifier_DistanceFromCamera *>(new_m);
932 q->color_ramp = MEM_dupalloc(p->color_ramp);
933 q->range_min = p->range_min;
934 q->range_max = p->range_max;
935 break;
936 }
940 const_cast<LineStyleModifier *>(m));
942 reinterpret_cast<LineStyleColorModifier_DistanceFromObject *>(new_m);
943 q->target = p->target;
944 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
945 id_us_plus(id_cast<ID *>(q->target));
946 }
947 q->color_ramp = MEM_dupalloc(p->color_ramp);
948 q->range_min = p->range_min;
949 q->range_max = p->range_max;
950 break;
951 }
954 const_cast<LineStyleModifier *>(m));
956 new_m);
957 q->color_ramp = MEM_dupalloc(p->color_ramp);
958 q->flags = p->flags;
959 q->mat_attr = p->mat_attr;
960 break;
961 }
962 case LS_MODIFIER_TANGENT: {
964 const_cast<LineStyleModifier *>(m));
966 new_m);
967 q->color_ramp = MEM_dupalloc(p->color_ramp);
968 break;
969 }
970 case LS_MODIFIER_NOISE: {
972 const_cast<LineStyleModifier *>(m));
973 LineStyleColorModifier_Noise *q = reinterpret_cast<LineStyleColorModifier_Noise *>(new_m);
974 q->color_ramp = MEM_dupalloc(p->color_ramp);
975 q->amplitude = p->amplitude;
976 q->period = p->period;
977 q->seed = p->seed;
978 break;
979 }
982 reinterpret_cast<LineStyleColorModifier_CreaseAngle *>(
983 const_cast<LineStyleModifier *>(m));
985 reinterpret_cast<LineStyleColorModifier_CreaseAngle *>(new_m);
986 q->color_ramp = MEM_dupalloc(p->color_ramp);
987 q->min_angle = p->min_angle;
988 q->max_angle = p->max_angle;
989 break;
990 }
993 reinterpret_cast<LineStyleColorModifier_Curvature_3D *>(
994 const_cast<LineStyleModifier *>(m));
996 reinterpret_cast<LineStyleColorModifier_Curvature_3D *>(new_m);
997 q->color_ramp = MEM_dupalloc(p->color_ramp);
1000 break;
1001 }
1002 default:
1003 return nullptr; /* unknown modifier type */
1004 }
1005 add_to_modifier_list(&linestyle->color_modifiers, new_m);
1006
1007 return new_m;
1008}
1009
1011{
1012 if (BLI_findindex(&linestyle->color_modifiers, m) == -1) {
1013 return -1;
1014 }
1015 switch (m->type) {
1017 MEM_delete((reinterpret_cast<LineStyleColorModifier_AlongStroke *>(m))->color_ramp);
1018 break;
1020 MEM_delete((reinterpret_cast<LineStyleColorModifier_DistanceFromCamera *>(m))->color_ramp);
1021 break;
1023 MEM_delete((reinterpret_cast<LineStyleColorModifier_DistanceFromObject *>(m))->color_ramp);
1024 break;
1026 MEM_delete((reinterpret_cast<LineStyleColorModifier_Material *>(m))->color_ramp);
1027 break;
1029 MEM_delete((reinterpret_cast<LineStyleColorModifier_Tangent *>(m))->color_ramp);
1030 break;
1031 case LS_MODIFIER_NOISE:
1032 MEM_delete((reinterpret_cast<LineStyleColorModifier_Noise *>(m))->color_ramp);
1033 break;
1035 MEM_delete((reinterpret_cast<LineStyleColorModifier_CreaseAngle *>(m))->color_ramp);
1036 break;
1038 MEM_delete((reinterpret_cast<LineStyleColorModifier_Curvature_3D *>(m))->color_ramp);
1039 break;
1040 default:
1041 break;
1042 }
1043 BLI_freelinkN(&linestyle->color_modifiers, m);
1044 return 0;
1045}
1046
1048{
1049 switch (type) {
1057 return sizeof(LineStyleAlphaModifier_Material);
1059 return sizeof(LineStyleAlphaModifier_Tangent);
1060 case LS_MODIFIER_NOISE:
1061 return sizeof(LineStyleAlphaModifier_Noise);
1066 default:
1067 return 0; /* unknown modifier type */
1068 }
1069}
1070
1072{
1073 const size_t size = alpha_modifier_struct_size(type);
1074 if (size == 0) {
1075 return nullptr;
1076 }
1077 return new_modifier(name, type, size);
1078}
1079
1081 const char *name,
1083{
1085
1086 m = alloc_alpha_modifier(name, type);
1087 m->blend = LS_VALUE_BLEND;
1088
1089 switch (type) {
1092 reinterpret_cast<LineStyleAlphaModifier_AlongStroke *>(m);
1093 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1094 break;
1095 }
1098 reinterpret_cast<LineStyleAlphaModifier_DistanceFromCamera *>(m);
1099 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1100 p->range_min = 0.0f;
1101 p->range_max = 10000.0f;
1102 break;
1103 }
1106 reinterpret_cast<LineStyleAlphaModifier_DistanceFromObject *>(m);
1107 p->target = nullptr;
1108 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1109 p->range_min = 0.0f;
1110 p->range_max = 10000.0f;
1111 break;
1112 }
1113 case LS_MODIFIER_MATERIAL: {
1115 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1117 break;
1118 }
1119 case LS_MODIFIER_TANGENT: {
1121 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1122 break;
1123 }
1124 case LS_MODIFIER_NOISE: {
1126 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1127 (reinterpret_cast<LineStyleAlphaModifier_Noise *>(m))->amplitude = 10.0f;
1128 (reinterpret_cast<LineStyleAlphaModifier_Noise *>(m))->period = 10.0f;
1129 (reinterpret_cast<LineStyleAlphaModifier_Noise *>(m))->seed = 512;
1130 break;
1131 }
1134 reinterpret_cast<LineStyleAlphaModifier_CreaseAngle *>(m);
1135 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1136 (reinterpret_cast<LineStyleAlphaModifier_CreaseAngle *>(m))->min_angle = 0.0f;
1137 (reinterpret_cast<LineStyleAlphaModifier_CreaseAngle *>(m))->max_angle = DEG2RADF(180.0f);
1138 break;
1139 }
1142 reinterpret_cast<LineStyleAlphaModifier_Curvature_3D *>(m);
1143 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1144 (reinterpret_cast<LineStyleAlphaModifier_Curvature_3D *>(m))->min_curvature = 0.0f;
1145 (reinterpret_cast<LineStyleAlphaModifier_Curvature_3D *>(m))->max_curvature = 0.5f;
1146 break;
1147 }
1148 default:
1149 return nullptr; /* unknown modifier type */
1150 }
1151 add_to_modifier_list(&linestyle->alpha_modifiers, m);
1152
1153 return m;
1154}
1155
1157 const LineStyleModifier *m,
1158 const int /*flag*/)
1159{
1160 LineStyleModifier *new_m;
1161
1162 new_m = alloc_alpha_modifier(m->name, m->type);
1163 if (new_m == nullptr) [[unlikely]] {
1164 return nullptr;
1165 }
1166 new_m->influence = m->influence;
1167 new_m->flags = m->flags;
1168 new_m->blend = m->blend;
1169
1170 switch (m->type) {
1173 reinterpret_cast<LineStyleAlphaModifier_AlongStroke *>(
1174 const_cast<LineStyleModifier *>(m));
1176 reinterpret_cast<LineStyleAlphaModifier_AlongStroke *>(new_m);
1178 q->flags = p->flags;
1179 break;
1180 }
1184 const_cast<LineStyleModifier *>(m));
1186 reinterpret_cast<LineStyleAlphaModifier_DistanceFromCamera *>(new_m);
1188 q->flags = p->flags;
1189 q->range_min = p->range_min;
1190 q->range_max = p->range_max;
1191 break;
1192 }
1196 const_cast<LineStyleModifier *>(m));
1198 reinterpret_cast<LineStyleAlphaModifier_DistanceFromObject *>(new_m);
1199 if (p->target) {
1200 id_us_plus(&p->target->id);
1201 }
1202 q->target = p->target;
1204 q->flags = p->flags;
1205 q->range_min = p->range_min;
1206 q->range_max = p->range_max;
1207 break;
1208 }
1209 case LS_MODIFIER_MATERIAL: {
1211 const_cast<LineStyleModifier *>(m));
1213 new_m);
1215 q->flags = p->flags;
1216 q->mat_attr = p->mat_attr;
1217 break;
1218 }
1219 case LS_MODIFIER_TANGENT: {
1221 const_cast<LineStyleModifier *>(m));
1223 new_m);
1225 q->flags = p->flags;
1226 break;
1227 }
1228 case LS_MODIFIER_NOISE: {
1230 const_cast<LineStyleModifier *>(m));
1231 LineStyleAlphaModifier_Noise *q = reinterpret_cast<LineStyleAlphaModifier_Noise *>(new_m);
1233 q->flags = p->flags;
1234 q->amplitude = p->amplitude;
1235 q->period = p->period;
1236 q->seed = p->seed;
1237 break;
1238 }
1241 reinterpret_cast<LineStyleAlphaModifier_CreaseAngle *>(
1242 const_cast<LineStyleModifier *>(m));
1244 reinterpret_cast<LineStyleAlphaModifier_CreaseAngle *>(new_m);
1246 q->flags = p->flags;
1247 q->min_angle = p->min_angle;
1248 q->max_angle = p->max_angle;
1249 break;
1250 }
1253 reinterpret_cast<LineStyleAlphaModifier_Curvature_3D *>(
1254 const_cast<LineStyleModifier *>(m));
1256 reinterpret_cast<LineStyleAlphaModifier_Curvature_3D *>(new_m);
1258 q->flags = p->flags;
1261 break;
1262 }
1263 default:
1264 return nullptr; /* unknown modifier type */
1265 }
1266 add_to_modifier_list(&linestyle->alpha_modifiers, new_m);
1267
1268 return new_m;
1269}
1270
1272{
1273 if (BLI_findindex(&linestyle->alpha_modifiers, m) == -1) {
1274 return -1;
1275 }
1276 switch (m->type) {
1278 BKE_curvemapping_free((reinterpret_cast<LineStyleAlphaModifier_AlongStroke *>(m))->curve);
1279 break;
1282 (reinterpret_cast<LineStyleAlphaModifier_DistanceFromCamera *>(m))->curve);
1283 break;
1286 (reinterpret_cast<LineStyleAlphaModifier_DistanceFromObject *>(m))->curve);
1287 break;
1289 BKE_curvemapping_free((reinterpret_cast<LineStyleAlphaModifier_Material *>(m))->curve);
1290 break;
1292 BKE_curvemapping_free((reinterpret_cast<LineStyleAlphaModifier_Tangent *>(m))->curve);
1293 break;
1294 case LS_MODIFIER_NOISE:
1295 BKE_curvemapping_free((reinterpret_cast<LineStyleAlphaModifier_Noise *>(m))->curve);
1296 break;
1298 BKE_curvemapping_free((reinterpret_cast<LineStyleAlphaModifier_CreaseAngle *>(m))->curve);
1299 break;
1301 BKE_curvemapping_free((reinterpret_cast<LineStyleAlphaModifier_Curvature_3D *>(m))->curve);
1302 break;
1303 default:
1304 break;
1305 }
1306 BLI_freelinkN(&linestyle->alpha_modifiers, m);
1307 return 0;
1308}
1309
1311{
1312 switch (type) {
1325 case LS_MODIFIER_NOISE:
1326 return sizeof(LineStyleThicknessModifier_Noise);
1331 default:
1332 return 0; /* unknown modifier type */
1333 }
1334}
1335
1337{
1338 const size_t size = thickness_modifier_struct_size(type);
1339 if (size == 0) {
1340 return nullptr;
1341 }
1342 return new_modifier(name, type, size);
1343}
1344
1346 const char *name,
1348{
1350
1351 m = alloc_thickness_modifier(name, type);
1352 m->blend = LS_VALUE_BLEND;
1353
1354 switch (type) {
1357 reinterpret_cast<LineStyleThicknessModifier_AlongStroke *>(m);
1358 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1359 p->value_min = 0.0f;
1360 p->value_max = 1.0f;
1361 break;
1362 }
1365 reinterpret_cast<LineStyleThicknessModifier_DistanceFromCamera *>(m);
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 }
1375 reinterpret_cast<LineStyleThicknessModifier_DistanceFromObject *>(m);
1376 p->target = nullptr;
1377 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1378 p->range_min = 0.0f;
1379 p->range_max = 1000.0f;
1380 p->value_min = 0.0f;
1381 p->value_max = 1.0f;
1382 break;
1383 }
1384 case LS_MODIFIER_MATERIAL: {
1386 reinterpret_cast<LineStyleThicknessModifier_Material *>(m);
1387 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1389 p->value_min = 0.0f;
1390 p->value_max = 1.0f;
1391 break;
1392 }
1395 reinterpret_cast<LineStyleThicknessModifier_Calligraphy *>(m);
1396 p->min_thickness = 1.0f;
1397 p->max_thickness = 10.0f;
1398 p->orientation = DEG2RADF(60.0f);
1399 break;
1400 }
1401 case LS_MODIFIER_TANGENT: {
1403 reinterpret_cast<LineStyleThicknessModifier_Tangent *>(m);
1404 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1405 p->min_thickness = 1.0f;
1406 p->max_thickness = 10.0f;
1407 break;
1408 }
1409 case LS_MODIFIER_NOISE: {
1411 m);
1412 p->period = 10.0f;
1413 p->amplitude = 10.0f;
1414 p->seed = 512;
1416 break;
1417 }
1420 reinterpret_cast<LineStyleThicknessModifier_CreaseAngle *>(m);
1421 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1422 p->min_angle = 0.0f;
1423 p->max_angle = DEG2RADF(180.0f);
1424 p->min_thickness = 1.0f;
1425 p->max_thickness = 10.0f;
1426 break;
1427 }
1430 reinterpret_cast<LineStyleThicknessModifier_Curvature_3D *>(m);
1431 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1432 p->min_curvature = 0.0f;
1433 p->max_curvature = 0.5f;
1434 p->min_thickness = 1.0f;
1435 p->max_thickness = 10.0f;
1436 break;
1437 }
1438 default:
1439 return nullptr; /* unknown modifier type */
1440 }
1442
1443 return m;
1444}
1445
1447 const LineStyleModifier *m,
1448 const int flag)
1449{
1450 LineStyleModifier *new_m;
1451
1452 new_m = alloc_thickness_modifier(m->name, m->type);
1453 if (!new_m) {
1454 return nullptr;
1455 }
1456 new_m->influence = m->influence;
1457 new_m->flags = m->flags;
1458 new_m->blend = m->blend;
1459
1460 switch (m->type) {
1463 reinterpret_cast<LineStyleThicknessModifier_AlongStroke *>(
1464 const_cast<LineStyleModifier *>(m));
1466 reinterpret_cast<LineStyleThicknessModifier_AlongStroke *>(new_m);
1468 q->flags = p->flags;
1469 q->value_min = p->value_min;
1470 q->value_max = p->value_max;
1471 break;
1472 }
1476 const_cast<LineStyleModifier *>(m));
1478 reinterpret_cast<LineStyleThicknessModifier_DistanceFromCamera *>(new_m);
1480 q->flags = p->flags;
1481 q->range_min = p->range_min;
1482 q->range_max = p->range_max;
1483 q->value_min = p->value_min;
1484 q->value_max = p->value_max;
1485 break;
1486 }
1490 const_cast<LineStyleModifier *>(m));
1492 reinterpret_cast<LineStyleThicknessModifier_DistanceFromObject *>(new_m);
1493 q->target = p->target;
1494 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
1495 id_us_plus(id_cast<ID *>(q->target));
1496 }
1498 q->flags = p->flags;
1499 q->range_min = p->range_min;
1500 q->range_max = p->range_max;
1501 q->value_min = p->value_min;
1502 q->value_max = p->value_max;
1503 break;
1504 }
1505 case LS_MODIFIER_MATERIAL: {
1507 reinterpret_cast<LineStyleThicknessModifier_Material *>(
1508 const_cast<LineStyleModifier *>(m));
1510 reinterpret_cast<LineStyleThicknessModifier_Material *>(new_m);
1512 q->flags = p->flags;
1513 q->mat_attr = p->mat_attr;
1514 q->value_min = p->value_min;
1515 q->value_max = p->value_max;
1516 break;
1517 }
1520 reinterpret_cast<LineStyleThicknessModifier_Calligraphy *>(
1521 const_cast<LineStyleModifier *>(m));
1523 reinterpret_cast<LineStyleThicknessModifier_Calligraphy *>(new_m);
1526 q->orientation = p->orientation;
1527 break;
1528 }
1529 case LS_MODIFIER_TANGENT: {
1531 reinterpret_cast<LineStyleThicknessModifier_Tangent *>(
1532 const_cast<LineStyleModifier *>(m));
1534 reinterpret_cast<LineStyleThicknessModifier_Tangent *>(new_m);
1536 q->flags = p->flags;
1539 break;
1540 }
1541 case LS_MODIFIER_NOISE: {
1543 const_cast<LineStyleModifier *>(m));
1545 new_m);
1546 q->amplitude = p->amplitude;
1547 q->period = p->period;
1548 q->seed = p->seed;
1549 q->flags = p->flags;
1550 break;
1551 }
1554 reinterpret_cast<LineStyleThicknessModifier_Curvature_3D *>(
1555 const_cast<LineStyleModifier *>(m));
1557 reinterpret_cast<LineStyleThicknessModifier_Curvature_3D *>(new_m);
1559 q->flags = p->flags;
1564 break;
1565 }
1568 reinterpret_cast<LineStyleThicknessModifier_CreaseAngle *>(
1569 const_cast<LineStyleModifier *>(m));
1571 reinterpret_cast<LineStyleThicknessModifier_CreaseAngle *>(new_m);
1573 q->flags = p->flags;
1574 q->min_angle = p->min_angle;
1575 q->max_angle = p->max_angle;
1578 break;
1579 }
1580 default:
1581 return nullptr; /* unknown modifier type */
1582 }
1583 add_to_modifier_list(&linestyle->thickness_modifiers, new_m);
1584
1585 return new_m;
1586}
1587
1589{
1590 if (BLI_findindex(&linestyle->thickness_modifiers, m) == -1) {
1591 return -1;
1592 }
1593 switch (m->type) {
1596 (reinterpret_cast<LineStyleThicknessModifier_AlongStroke *>(m))->curve);
1597 break;
1600 (reinterpret_cast<LineStyleThicknessModifier_DistanceFromCamera *>(m))->curve);
1601 break;
1604 (reinterpret_cast<LineStyleThicknessModifier_DistanceFromObject *>(m))->curve);
1605 break;
1607 BKE_curvemapping_free((reinterpret_cast<LineStyleThicknessModifier_Material *>(m))->curve);
1608 break;
1610 break;
1612 BKE_curvemapping_free((reinterpret_cast<LineStyleThicknessModifier_Tangent *>(m))->curve);
1613 break;
1614 case LS_MODIFIER_NOISE:
1615 break;
1618 (reinterpret_cast<LineStyleThicknessModifier_CreaseAngle *>(m))->curve);
1619 break;
1622 (reinterpret_cast<LineStyleThicknessModifier_Curvature_3D *>(m))->curve);
1623 break;
1624 default:
1625 break;
1626 }
1627 BLI_freelinkN(&linestyle->thickness_modifiers, m);
1628 return 0;
1629}
1630
1632{
1633 switch (type) {
1662 default:
1663 return 0; /* unknown modifier type */
1664 }
1665}
1666
1668{
1669 const size_t size = geometry_modifier_struct_size(type);
1670 if (size == 0) {
1671 return nullptr;
1672 }
1673 return new_modifier(name, type, size);
1674}
1675
1677 const char *name,
1679{
1681
1682 m = alloc_geometry_modifier(name, type);
1683
1684 switch (type) {
1685 case LS_MODIFIER_SAMPLING: {
1687 reinterpret_cast<LineStyleGeometryModifier_Sampling *>(m);
1688 p->sampling = 10.0f;
1689 break;
1690 }
1693 reinterpret_cast<LineStyleGeometryModifier_BezierCurve *>(m);
1694 p->error = 10.0f;
1695 break;
1696 }
1699 reinterpret_cast<LineStyleGeometryModifier_SinusDisplacement *>(m);
1700 p->wavelength = 20.0f;
1701 p->amplitude = 5.0f;
1702 p->phase = 0.0f;
1703 break;
1704 }
1707 reinterpret_cast<LineStyleGeometryModifier_SpatialNoise *>(m);
1708 p->amplitude = 5.0f;
1709 p->scale = 20.0f;
1710 p->octaves = 4;
1712 break;
1713 }
1716 reinterpret_cast<LineStyleGeometryModifier_PerlinNoise1D *>(m);
1717 p->frequency = 10.0f;
1718 p->amplitude = 10.0f;
1719 p->octaves = 4;
1720 p->angle = DEG2RADF(45.0f);
1721 break;
1722 }
1725 reinterpret_cast<LineStyleGeometryModifier_PerlinNoise2D *>(m);
1726 p->frequency = 10.0f;
1727 p->amplitude = 10.0f;
1728 p->octaves = 4;
1729 p->angle = DEG2RADF(45.0f);
1730 break;
1731 }
1734 reinterpret_cast<LineStyleGeometryModifier_BackboneStretcher *>(m);
1735 p->backbone_length = 10.0f;
1736 break;
1737 }
1740 reinterpret_cast<LineStyleGeometryModifier_TipRemover *>(m);
1741 p->tip_length = 10.0f;
1742 break;
1743 }
1746 reinterpret_cast<LineStyleGeometryModifier_Polygonalization *>(m);
1747 p->error = 10.0f;
1748 break;
1749 }
1752 reinterpret_cast<LineStyleGeometryModifier_GuidingLines *>(m);
1753 p->offset = 0.0f;
1754 break;
1755 }
1756 case LS_MODIFIER_BLUEPRINT: {
1758 reinterpret_cast<LineStyleGeometryModifier_Blueprint *>(m);
1760 p->rounds = 1;
1761 p->backbone_length = 10.0f;
1762 p->random_radius = 3;
1763 p->random_center = 5;
1764 p->random_backbone = 5;
1765 break;
1766 }
1767 case LS_MODIFIER_2D_OFFSET: {
1769 reinterpret_cast<LineStyleGeometryModifier_2DOffset *>(m);
1770 p->start = 0.0f;
1771 p->end = 0.0f;
1772 p->x = 0.0f;
1773 p->y = 0.0f;
1774 break;
1775 }
1778 reinterpret_cast<LineStyleGeometryModifier_2DTransform *>(m);
1780 p->scale_x = 1.0f;
1781 p->scale_y = 1.0f;
1782 p->angle = DEG2RADF(0.0f);
1783 p->pivot_u = 0.5f;
1784 p->pivot_x = 0.0f;
1785 p->pivot_y = 0.0f;
1786 break;
1787 }
1790 reinterpret_cast<LineStyleGeometryModifier_Simplification *>(m);
1791 p->tolerance = 0.1f;
1792 break;
1793 }
1794 default:
1795 return nullptr; /* unknown modifier type */
1796 }
1798
1799 return m;
1800}
1801
1803 const LineStyleModifier *m,
1804 const int /*flag*/)
1805{
1806 LineStyleModifier *new_m;
1807
1808 new_m = alloc_geometry_modifier(m->name, m->type);
1809 if (new_m == nullptr) [[unlikely]] {
1810 return nullptr;
1811 }
1812 new_m->flags = m->flags;
1813
1814 switch (m->type) {
1815 case LS_MODIFIER_SAMPLING: {
1817 reinterpret_cast<LineStyleGeometryModifier_Sampling *>(
1818 const_cast<LineStyleModifier *>(m));
1820 reinterpret_cast<LineStyleGeometryModifier_Sampling *>(new_m);
1821 q->sampling = p->sampling;
1822 break;
1823 }
1826 reinterpret_cast<LineStyleGeometryModifier_BezierCurve *>(
1827 const_cast<LineStyleModifier *>(m));
1829 reinterpret_cast<LineStyleGeometryModifier_BezierCurve *>(new_m);
1830 q->error = p->error;
1831 break;
1832 }
1836 const_cast<LineStyleModifier *>(m));
1838 reinterpret_cast<LineStyleGeometryModifier_SinusDisplacement *>(new_m);
1839 q->wavelength = p->wavelength;
1840 q->amplitude = p->amplitude;
1841 q->phase = p->phase;
1842 break;
1843 }
1846 reinterpret_cast<LineStyleGeometryModifier_SpatialNoise *>(
1847 const_cast<LineStyleModifier *>(m));
1849 reinterpret_cast<LineStyleGeometryModifier_SpatialNoise *>(new_m);
1850 q->amplitude = p->amplitude;
1851 q->scale = p->scale;
1852 q->octaves = p->octaves;
1853 q->flags = p->flags;
1854 break;
1855 }
1858 reinterpret_cast<LineStyleGeometryModifier_PerlinNoise1D *>(
1859 const_cast<LineStyleModifier *>(m));
1861 reinterpret_cast<LineStyleGeometryModifier_PerlinNoise1D *>(new_m);
1862 q->frequency = p->frequency;
1863 q->amplitude = p->amplitude;
1864 q->angle = p->angle;
1865 q->octaves = p->octaves;
1866 q->seed = p->seed;
1867 break;
1868 }
1871 reinterpret_cast<LineStyleGeometryModifier_PerlinNoise2D *>(
1872 const_cast<LineStyleModifier *>(m));
1874 reinterpret_cast<LineStyleGeometryModifier_PerlinNoise2D *>(new_m);
1875 q->frequency = p->frequency;
1876 q->amplitude = p->amplitude;
1877 q->angle = p->angle;
1878 q->octaves = p->octaves;
1879 q->seed = p->seed;
1880 break;
1881 }
1885 const_cast<LineStyleModifier *>(m));
1887 reinterpret_cast<LineStyleGeometryModifier_BackboneStretcher *>(new_m);
1889 break;
1890 }
1893 reinterpret_cast<LineStyleGeometryModifier_TipRemover *>(
1894 const_cast<LineStyleModifier *>(m));
1896 reinterpret_cast<LineStyleGeometryModifier_TipRemover *>(new_m);
1897 q->tip_length = p->tip_length;
1898 break;
1899 }
1903 const_cast<LineStyleModifier *>(m));
1905 reinterpret_cast<LineStyleGeometryModifier_Polygonalization *>(new_m);
1906 q->error = p->error;
1907 break;
1908 }
1911 reinterpret_cast<LineStyleGeometryModifier_GuidingLines *>(
1912 const_cast<LineStyleModifier *>(m));
1914 reinterpret_cast<LineStyleGeometryModifier_GuidingLines *>(new_m);
1915 q->offset = p->offset;
1916 break;
1917 }
1918 case LS_MODIFIER_BLUEPRINT: {
1920 reinterpret_cast<LineStyleGeometryModifier_Blueprint *>(
1921 const_cast<LineStyleModifier *>(m));
1923 reinterpret_cast<LineStyleGeometryModifier_Blueprint *>(new_m);
1924 q->flags = p->flags;
1925 q->rounds = p->rounds;
1930 break;
1931 }
1932 case LS_MODIFIER_2D_OFFSET: {
1934 reinterpret_cast<LineStyleGeometryModifier_2DOffset *>(
1935 const_cast<LineStyleModifier *>(m));
1937 reinterpret_cast<LineStyleGeometryModifier_2DOffset *>(new_m);
1938 q->start = p->start;
1939 q->end = p->end;
1940 q->x = p->x;
1941 q->y = p->y;
1942 break;
1943 }
1946 reinterpret_cast<LineStyleGeometryModifier_2DTransform *>(
1947 const_cast<LineStyleModifier *>(m));
1949 reinterpret_cast<LineStyleGeometryModifier_2DTransform *>(new_m);
1950 q->pivot = p->pivot;
1951 q->scale_x = p->scale_x;
1952 q->scale_y = p->scale_y;
1953 q->angle = p->angle;
1954 q->pivot_u = p->pivot_u;
1955 q->pivot_x = p->pivot_x;
1956 q->pivot_y = p->pivot_y;
1957 break;
1958 }
1961 reinterpret_cast<LineStyleGeometryModifier_Simplification *>(
1962 const_cast<LineStyleModifier *>(m));
1964 reinterpret_cast<LineStyleGeometryModifier_Simplification *>(new_m);
1965 q->tolerance = p->tolerance;
1966 break;
1967 }
1968 default:
1969 return nullptr; /* unknown modifier type */
1970 }
1971 add_to_modifier_list(&linestyle->geometry_modifiers, new_m);
1972
1973 return new_m;
1974}
1975
1977{
1978 if (BLI_findindex(&linestyle->geometry_modifiers, m) == -1) {
1979 return -1;
1980 }
1981 BLI_freelinkN(&linestyle->geometry_modifiers, m);
1982 return 0;
1983}
1984
1987 int direction)
1988{
1989 return BLI_listbase_link_move(&linestyle->color_modifiers, modifier, direction);
1990}
1993 int direction)
1994{
1995 return BLI_listbase_link_move(&linestyle->alpha_modifiers, modifier, direction);
1996}
1999 int direction)
2000{
2001 return BLI_listbase_link_move(&linestyle->thickness_modifiers, modifier, direction);
2002}
2005 int direction)
2006{
2007 return BLI_listbase_link_move(&linestyle->geometry_modifiers, modifier, direction);
2008}
2009
2011 ListBaseT<LinkData> *listbase)
2012{
2013 ColorBand *color_ramp;
2014 LinkData *link;
2015
2016 listbase->clear_no_delete();
2017
2018 for (LineStyleModifier &m : linestyle->color_modifiers) {
2019 switch (m.type) {
2021 color_ramp = (reinterpret_cast<LineStyleColorModifier_AlongStroke *>(&m))->color_ramp;
2022 break;
2024 color_ramp =
2025 (reinterpret_cast<LineStyleColorModifier_DistanceFromCamera *>(&m))->color_ramp;
2026 break;
2028 color_ramp =
2029 (reinterpret_cast<LineStyleColorModifier_DistanceFromObject *>(&m))->color_ramp;
2030 break;
2032 color_ramp = (reinterpret_cast<LineStyleColorModifier_Material *>(&m))->color_ramp;
2033 break;
2034 default:
2035 continue;
2036 }
2037 link = MEM_new_zeroed<LinkData>("link to color ramp");
2038 link->data = color_ramp;
2039 BLI_addtail(listbase, link);
2040 }
2041}
2042
2043std::optional<std::string> BKE_linestyle_path_to_color_ramp(FreestyleLineStyle *linestyle,
2044 const ColorBand *color_ramp)
2045{
2046 bool found = false;
2047
2048 for (LineStyleModifier &m : linestyle->color_modifiers) {
2049 switch (m.type) {
2051 if (color_ramp == (reinterpret_cast<LineStyleColorModifier_AlongStroke *>(&m))->color_ramp)
2052 {
2053 found = true;
2054 }
2055 break;
2057 if (color_ramp ==
2058 (reinterpret_cast<LineStyleColorModifier_DistanceFromCamera *>(&m))->color_ramp)
2059 {
2060 found = true;
2061 }
2062 break;
2064 if (color_ramp ==
2065 (reinterpret_cast<LineStyleColorModifier_DistanceFromObject *>(&m))->color_ramp)
2066 {
2067 found = true;
2068 }
2069 break;
2071 if (color_ramp == (reinterpret_cast<LineStyleColorModifier_Material *>(&m))->color_ramp) {
2072 found = true;
2073 }
2074 break;
2076 if (color_ramp == (reinterpret_cast<LineStyleColorModifier_Tangent *>(&m))->color_ramp) {
2077 found = true;
2078 }
2079 break;
2080 case LS_MODIFIER_NOISE:
2081 if (color_ramp == (reinterpret_cast<LineStyleColorModifier_Noise *>(&m))->color_ramp) {
2082 found = true;
2083 }
2084 break;
2086 if (color_ramp == (reinterpret_cast<LineStyleColorModifier_CreaseAngle *>(&m))->color_ramp)
2087 {
2088 found = true;
2089 }
2090 break;
2092 if (color_ramp ==
2093 (reinterpret_cast<LineStyleColorModifier_Curvature_3D *>(&m))->color_ramp)
2094 {
2095 found = true;
2096 }
2097 break;
2098 default:
2099 break;
2100 }
2101
2102 if (found) {
2103 char name_esc[sizeof(m.name) * 2];
2104 BLI_str_escape(name_esc, m.name, sizeof(name_esc));
2105 return fmt::format("color_modifiers[\"{}\"].color_ramp", name_esc);
2106 }
2107 }
2108 printf("BKE_linestyle_path_to_color_ramp: No color ramps correspond to the given pointer.\n");
2109 return std::nullopt;
2110}
2111
2112bool BKE_linestyle_use_textures(FreestyleLineStyle *linestyle, const bool use_shading_nodes)
2113{
2114 if (use_shading_nodes) {
2115 if (linestyle && linestyle->use_nodes && linestyle->nodetree) {
2116 for (bNode &node : linestyle->nodetree->nodes) {
2117 if (node.typeinfo->nclass == NODE_CLASS_TEXTURE) {
2118 return true;
2119 }
2120 }
2121 }
2122 }
2123 else {
2124 if (linestyle && (linestyle->flag & LS_TEXTURE)) {
2125 return (linestyle->mtex[0] != nullptr);
2126 }
2127 }
2128 return false;
2129}
2130
2132{
2133 bNode *uv_along_stroke, *input_texture, *output_linestyle;
2134 bNodeSocket *fromsock, *tosock;
2135 bNodeTree *ntree;
2136
2137 BLI_assert(linestyle->nodetree == nullptr);
2138
2140 nullptr, &linestyle->id, "stroke_shader", "ShaderNodeTree");
2141
2142 uv_along_stroke = bke::node_add_static_node(C, *ntree, SH_NODE_UVALONGSTROKE);
2143 uv_along_stroke->location[0] = -200.0f;
2144 uv_along_stroke->location[1] = 100.0f;
2145 uv_along_stroke->custom1 = 0; /* use_tips */
2146
2147 input_texture = bke::node_add_static_node(C, *ntree, SH_NODE_TEX_IMAGE);
2148 input_texture->location[0] = 0.0f;
2149 input_texture->location[1] = 100.0f;
2150
2151 output_linestyle = bke::node_add_static_node(C, *ntree, SH_NODE_OUTPUT_LINESTYLE);
2152 output_linestyle->location[0] = 300.0f;
2153 output_linestyle->location[1] = 100.0f;
2154 output_linestyle->custom1 = MA_RAMP_BLEND;
2155 output_linestyle->custom2 = 0; /* use_clamp */
2156
2157 bke::node_set_active(*ntree, *input_texture);
2158
2159 fromsock = static_cast<bNodeSocket *>(BLI_findlink(&uv_along_stroke->outputs, 0)); /* UV */
2160 tosock = static_cast<bNodeSocket *>(BLI_findlink(&input_texture->inputs, 0)); /* UV */
2161 bke::node_add_link(*ntree, *uv_along_stroke, *fromsock, *input_texture, *tosock);
2162
2163 fromsock = static_cast<bNodeSocket *>(BLI_findlink(&input_texture->outputs, 0)); /* Color */
2164 tosock = static_cast<bNodeSocket *>(BLI_findlink(&output_linestyle->inputs, 0)); /* Color */
2165 bke::node_add_link(*ntree, *input_texture, *fromsock, *output_linestyle, *tosock);
2166
2168}
2169
2170} // namespace blender
#define BKE_LIB_FOREACHID_PROCESS_FUNCTION_CALL(data_, func_call_)
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER(data_, id_super_, cb_flag_)
Blender kernel freestyle line style functionality.
#define NODE_CLASS_TEXTURE
Definition BKE_node.hh:488
#define SH_NODE_TEX_IMAGE
#define SH_NODE_UVALONGSTROKE
#define SH_NODE_OUTPUT_LINESTYLE
#define DEG2RADF(_deg)
#define STRNCPY_UTF8(dst, src)
#define BLO_read_struct(reader, struct_name, ptr_p)
#define BLT_I18NCONTEXT_ID_FREESTYLELINESTYLE
#define DATA_(msgid)
#define FILTER_ID_OB
Definition DNA_ID.h:1216
#define FILTER_ID_TE
Definition DNA_ID.h:1222
#define FILTER_ID_LS
Definition DNA_ID.h:1208
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define MAX_MTEX
Definition Stroke.h:31
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
#define offsetof(t, d)
bNodeTree * node_tree_add_tree_embedded(Main *bmain, ID *owner_id, StringRefNull name, StringRefNull idname)
Definition node.cc:5005
void node_tree_blend_write(BlendWriter *writer, bNodeTree *ntree)
Definition node.cc:1361
bNode * node_add_static_node(const bContext *C, bNodeTree &ntree, int type)
Definition node.cc:4283
bNodeLink & node_add_link(bNodeTree &ntree, bNode &fromnode, bNodeSocket &fromsock, bNode &tonode, bNodeSocket &tosock)
Definition node.cc:4638
void node_set_active(bNodeTree &ntree, bNode &node)
Definition node.cc:5484
void node_tree_free_embedded_tree(bNodeTree *ntree)
Definition node.cc:5231
internal::ShallowDataConstRef< T > shallow_copy(const T &other)
Definition DNA_defs.h:147
int sdna_struct_id_get()
uint32_t struct_size(Span< shader::ShaderCreateInfo::PushConst > push_constants)
BMesh Iterators.
CurveMapping * BKE_curvemapping_add(int tot, float minx, float miny, float maxx, float maxy)
Definition colortools.cc:99
LineStyleModifier * BKE_linestyle_geometry_modifier_add(FreestyleLineStyle *linestyle, const char *name, eLineStyleModifier_Type type)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static void linestyle_blend_write(BlendWriter *writer, ID *id, const void *id_address)
Definition linestyle.cc:468
static void add_to_modifier_list(ListBaseT< LineStyleModifier > *lb, LineStyleModifier *m)
Definition linestyle.cc:796
void BKE_linestyle_init(struct FreestyleLineStyle *linestyle)
Definition linestyle.cc:757
CurveMapping * BKE_curvemapping_copy(const CurveMapping *cumap)
void BKE_linestyle_modifier_list_color_ramps(FreestyleLineStyle *linestyle, ListBaseT< LinkData > *listbase)
LineStyleModifier * BKE_linestyle_thickness_modifier_copy(FreestyleLineStyle *linestyle, const LineStyleModifier *m, int flag)
static void direct_link_linestyle_color_modifier(BlendDataReader *reader, LineStyleModifier *modifier)
Definition linestyle.cc:492
@ LS_MODIFIER_2D_TRANSFORM_PIVOT_CENTER
static void linestyle_blend_read_data(BlendDataReader *reader, ID *id)
Definition linestyle.cc:690
static void write_linestyle_color_modifiers(BlendWriter *writer, ListBaseT< LineStyleModifier > *modifiers)
Definition linestyle.cc:189
void id_us_plus(ID *id)
Definition lib_id.cc:433
static void linestyle_copy_data(Main *bmain, std::optional< Library * > owner_library, ID *id_dst, const ID *id_src, const int flag)
Definition linestyle.cc:61
int BKE_linestyle_thickness_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *modifier)
std::optional< std::string > BKE_linestyle_path_to_color_ramp(FreestyleLineStyle *linestyle, const struct ColorBand *color_ramp)
static void linestyle_foreach_working_space_color(ID *id, const IDTypeForeachColorFunctionCallback &fn)
Definition linestyle.cc:181
static const char * modifier_name[LS_MODIFIER_NUM]
Definition linestyle.cc:748
static size_t alpha_modifier_struct_size(eLineStyleModifier_Type type)
static LineStyleModifier * alloc_alpha_modifier(const char *name, eLineStyleModifier_Type type)
void BKE_curvemapping_blend_write(BlendWriter *writer, const CurveMapping *cumap)
static void write_linestyle_thickness_modifiers(BlendWriter *writer, ListBaseT< LineStyleModifier > *modifiers)
Definition linestyle.cc:337
@ LS_MODIFIER_BLUEPRINT_CIRCLES
ColorBand * BKE_colorband_add(bool rangetype)
Definition colorband.cc:301
static void direct_link_linestyle_thickness_modifier(BlendDataReader *reader, LineStyleModifier *modifier)
Definition linestyle.cc:612
void BKE_curvemapping_free(CurveMapping *cumap)
int BKE_linestyle_alpha_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *modifier)
void BKE_id_blend_write(BlendWriter *writer, ID *id)
Definition lib_id.cc:2890
static size_t geometry_modifier_struct_size(eLineStyleModifier_Type type)
@ LIB_ID_CREATE_NO_USER_REFCOUNT
@ LIB_ID_CREATE_NO_ALLOCATE
static void write_linestyle_geometry_modifiers(BlendWriter *writer, ListBaseT< LineStyleModifier > *modifiers)
Definition linestyle.cc:413
LineStyleModifier * BKE_linestyle_color_modifier_copy(FreestyleLineStyle *linestyle, const LineStyleModifier *m, int flag)
Definition linestyle.cc:902
bool BKE_linestyle_color_modifier_move(FreestyleLineStyle *linestyle, LineStyleModifier *modifier, int direction)
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
void BLI_uniquename(const ListBase *list, void *vlink, const char *defname, char delim, int name_offset, size_t name_maxncpy) ATTR_NONNULL(1
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
void BKE_curvemapping_blend_read(BlendDataReader *reader, CurveMapping *cumap)
@ LS_MODIFIER_SPATIAL_NOISE_SMOOTH
@ LS_MODIFIER_SPATIAL_NOISE_PURERANDOM
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
BMesh const char void * data
struct FreestyleLineSet * BKE_freestyle_lineset_get_active(struct FreestyleConfig *config)
Definition freestyle.cc:214
void BKE_library_foreach_ID_embedded(LibraryForeachIDData *data, ID **id_pp)
Definition lib_query.cc:176
char char size_t BLI_str_escape(char *__restrict dst, StringRef src, size_t dst_maxncpy) ATTR_NONNULL(1)
static void linestyle_foreach_id(ID *id, LibraryForeachIDData *data)
Definition linestyle.cc:142
static size_t color_modifier_struct_size(eLineStyleModifier_Type type)
Definition linestyle.cc:803
void BKE_ntree_update_after_single_tree_change(Main &bmain, bNodeTree &modified_tree, const NodeTreeUpdateExtraParams &params={})
int sdna_struct_id_get()
void BLO_read_struct_list_with_type_size(BlendDataReader *reader, size_t base_size, ListBase *list, FunctionRef< size_t(const void *data)> type_size_fn)
Definition readfile.cc:6591
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:277
FreestyleLineStyle * BKE_linestyle_new(struct Main *bmain, const char *name)
Definition linestyle.cc:762
@ LS_MODIFIER_PERLIN_NOISE_2D
@ LS_MODIFIER_BACKBONE_STRETCHER
@ LS_MODIFIER_PERLIN_NOISE_1D
@ LS_MODIFIER_DISTANCE_FROM_CAMERA
@ LS_MODIFIER_DISTANCE_FROM_OBJECT
@ LS_MODIFIER_SINUS_DISPLACEMENT
LineStyleModifier * BKE_linestyle_alpha_modifier_add(FreestyleLineStyle *linestyle, const char *name, eLineStyleModifier_Type type)
static void direct_link_linestyle_geometry_modifier(BlendDataReader *, LineStyleModifier *)
Definition linestyle.cc:670
static void linestyle_modifiers_read(BlendDataReader *reader, ListBaseT< LineStyleModifier > *modifiers, size_t(*struct_size)(eLineStyleModifier_Type))
Definition linestyle.cc:680
IDTypeInfo IDType_ID_LS
Definition linestyle.cc:716
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
static LineStyleModifier * new_modifier(const char *name, eLineStyleModifier_Type type, size_t size)
Definition linestyle.cc:780
Main * CTX_data_main(const bContext *C)
bool BKE_linestyle_thickness_modifier_move(FreestyleLineStyle *linestyle, LineStyleModifier *modifier, int direction)
@ INDEX_ID_LS
Definition DNA_ID.h:1315
LineStyleModifier * BKE_linestyle_thickness_modifier_add(FreestyleLineStyle *linestyle, const char *name, eLineStyleModifier_Type type)
FreestyleLineStyle * BKE_linestyle_active_from_view_layer(struct ViewLayer *view_layer)
Definition linestyle.cc:773
static void linestyle_init_data(ID *id)
Definition linestyle.cc:53
static LineStyleModifier * alloc_thickness_modifier(const char *name, eLineStyleModifier_Type type)
void BKE_texture_mtex_foreach_id(struct LibraryForeachIDData *data, struct MTex *mtex)
Definition texture.cc:217
static size_t thickness_modifier_struct_size(eLineStyleModifier_Type type)
static LineStyleModifier * alloc_geometry_modifier(const char *name, eLineStyleModifier_Type type)
bool BKE_linestyle_geometry_modifier_move(FreestyleLineStyle *linestyle, LineStyleModifier *modifier, int direction)
bool BKE_linestyle_alpha_modifier_move(FreestyleLineStyle *linestyle, LineStyleModifier *modifier, int direction)
LineStyleModifier * BKE_linestyle_color_modifier_add(FreestyleLineStyle *linestyle, const char *name, eLineStyleModifier_Type type)
Definition linestyle.cc:836
int BKE_linestyle_color_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *modifier)
LineStyleModifier * BKE_linestyle_geometry_modifier_copy(FreestyleLineStyle *linestyle, const LineStyleModifier *m, int flag)
void BKE_linestyle_default_shader(const struct bContext *C, FreestyleLineStyle *linestyle)
LineStyleModifier * BKE_linestyle_alpha_modifier_copy(FreestyleLineStyle *linestyle, const LineStyleModifier *m, int flag)
static void linestyle_free_data(ID *id)
Definition linestyle.cc:112
void * BKE_libblock_alloc(Main *bmain, short type, const char *name, int flag) ATTR_WARN_UNUSED_RESULT
Definition lib_id.cc:1545
struct ID * BKE_id_copy_in_lib(Main *bmain, std::optional< Library * > owner_library, const ID *id, std::optional< const ID * > new_owner_id, ID **new_id_p, int flag)
Definition lib_id.cc:749
static void write_linestyle_alpha_modifiers(BlendWriter *writer, ListBaseT< LineStyleModifier > *modifiers)
Definition linestyle.cc:262
static LineStyleModifier * alloc_color_modifier(const char *name, eLineStyleModifier_Type type)
Definition linestyle.cc:827
bool BKE_linestyle_use_textures(FreestyleLineStyle *linestyle, bool use_shading_nodes)
static void direct_link_linestyle_alpha_modifier(BlendDataReader *reader, LineStyleModifier *modifier)
Definition linestyle.cc:548
void void void bool BLI_listbase_link_move(ListBase *listbase, void *vlink, int step) ATTR_NONNULL()
Definition listbase.cc:443
int BKE_linestyle_geometry_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *modifier)
@ IDTYPE_FLAGS_APPEND_IS_REUSABLE
Definition BKE_idtype.hh:50
void write_struct_by_id(int struct_id, const void *data, BlendStructWriterFn fn=nullptr)
void write_embedded_id_struct(const void *id_address, const T *id, BlendStructWriterTypedFn< T > fn=nullptr)
void write_id_struct(const void *id_address, const T *id, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
struct FreestyleLineStyle * linestyle
ListBaseT< LineStyleModifier > color_modifiers
ListBaseT< LineStyleModifier > alpha_modifiers
ListBaseT< LineStyleModifier > thickness_modifiers
ListBaseT< LineStyleModifier > geometry_modifiers
eLineStyleAlphaThicknessModifier_Flag flags
eLineStyleAlphaThicknessModifier_Flag flags
eLineStyleAlphaThicknessModifier_Flag flags
eLineStyleAlphaThicknessModifier_Flag flags
eLineStyleAlphaThicknessModifier_Flag flags
eLineStyleAlphaThicknessModifier_Flag flags
eLineStyleModifier_Flag flags
eLineStyleModifier_Type type
eLineStyleAlphaThicknessModifier_Flag flags
eLineStyleAlphaThicknessModifier_Flag flags
eLineStyleAlphaThicknessModifier_Flag flags
eLineStyleAlphaThicknessModifier_Flag flags
eLineStyleAlphaThicknessModifier_Flag flags
struct FreestyleConfig freestyle_config
ListBaseT< bNode > nodes
ListBaseT< bNodeSocket > outputs
ListBaseT< bNodeSocket > inputs
#define N_(msgid)