Blender V4.5
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_defaults.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.h"
26#include "BLI_math_rotation.h"
27#include "BLI_string.h"
28#include "BLI_string_utils.hh"
29#include "BLI_utildefines.h"
30
31#include "BLT_translation.hh"
32
33#include "BKE_colorband.hh"
34#include "BKE_colortools.hh"
35#include "BKE_context.hh"
36#include "BKE_freestyle.h"
37#include "BKE_idtype.hh"
38#include "BKE_lib_id.hh"
39#include "BKE_lib_query.hh"
40#include "BKE_linestyle.h"
41#include "BKE_node.hh"
44#include "BKE_texture.h"
45
46#include "BLO_read_write.hh"
47
49
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 = (FreestyleLineStyle *)id_dst;
68 const FreestyleLineStyle *linestyle_src = (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_callocN<MTex>(__func__);
78 *linestyle_dst->mtex[a] = blender::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 BLI_listbase_clear(&linestyle_dst->color_modifiers);
92 LISTBASE_FOREACH (LineStyleModifier *, linestyle_modifier, &linestyle_src->color_modifiers) {
93 BKE_linestyle_color_modifier_copy(linestyle_dst, linestyle_modifier, flag_subdata);
94 }
95
96 BLI_listbase_clear(&linestyle_dst->alpha_modifiers);
97 LISTBASE_FOREACH (LineStyleModifier *, linestyle_modifier, &linestyle_src->alpha_modifiers) {
98 BKE_linestyle_alpha_modifier_copy(linestyle_dst, linestyle_modifier, flag_subdata);
99 }
100
102 LISTBASE_FOREACH (LineStyleModifier *, linestyle_modifier, &linestyle_src->thickness_modifiers) {
103 BKE_linestyle_thickness_modifier_copy(linestyle_dst, linestyle_modifier, flag_subdata);
104 }
105
106 BLI_listbase_clear(&linestyle_dst->geometry_modifiers);
107 LISTBASE_FOREACH (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 = (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_FREE(linestyle->mtex[material_slot_index]);
119 }
120
121 /* is no lib link block, but linestyle extension */
122 if (linestyle->nodetree) {
124 MEM_freeN(linestyle->nodetree);
125 linestyle->nodetree = nullptr;
126 }
127
128 while ((linestyle_modifier = (LineStyleModifier *)linestyle->color_modifiers.first)) {
129 BKE_linestyle_color_modifier_remove(linestyle, linestyle_modifier);
130 }
131 while ((linestyle_modifier = (LineStyleModifier *)linestyle->alpha_modifiers.first)) {
132 BKE_linestyle_alpha_modifier_remove(linestyle, linestyle_modifier);
133 }
134 while ((linestyle_modifier = (LineStyleModifier *)linestyle->thickness_modifiers.first)) {
135 BKE_linestyle_thickness_modifier_remove(linestyle, linestyle_modifier);
136 }
137 while ((linestyle_modifier = (LineStyleModifier *)linestyle->geometry_modifiers.first)) {
138 BKE_linestyle_geometry_modifier_remove(linestyle, linestyle_modifier);
139 }
140}
141
143{
144 FreestyleLineStyle *linestyle = (FreestyleLineStyle *)id;
145
146 for (int i = 0; i < MAX_MTEX; i++) {
147 if (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
159 if (lsm->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
161 lsm;
163 }
164 }
166 if (lsm->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
168 lsm;
170 }
171 }
173 if (lsm->type == LS_MODIFIER_DISTANCE_FROM_OBJECT) {
177 }
178 }
179}
180
182{
183 LISTBASE_FOREACH (LineStyleModifier *, m, modifiers) {
184 int struct_nr;
185 switch (m->type) {
188 break;
191 break;
194 break;
197 break;
200 break;
203 break;
206 break;
209 break;
210 default:
211 struct_nr = sdna_struct_id_get<LineStyleModifier>(); /* this should not happen */
212 }
213 BLO_write_struct_by_id(writer, struct_nr, m);
214 }
215 LISTBASE_FOREACH (LineStyleModifier *, m, modifiers) {
216 switch (m->type) {
219 break;
222 writer, ColorBand, ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp);
223 break;
226 writer, ColorBand, ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp);
227 break;
230 break;
232 BLO_write_struct(writer, ColorBand, ((LineStyleColorModifier_Tangent *)m)->color_ramp);
233 break;
235 BLO_write_struct(writer, ColorBand, ((LineStyleColorModifier_Noise *)m)->color_ramp);
236 break;
239 break;
242 writer, ColorBand, ((LineStyleColorModifier_Curvature_3D *)m)->color_ramp);
243 break;
244 }
245 }
246}
247
249{
250 LISTBASE_FOREACH (LineStyleModifier *, m, modifiers) {
251 int struct_nr;
252 switch (m->type) {
255 break;
258 break;
261 break;
264 break;
267 break;
270 break;
273 break;
276 break;
277 default:
278 struct_nr = sdna_struct_id_get<LineStyleModifier>(); /* this should not happen */
279 }
280 BLO_write_struct_by_id(writer, struct_nr, m);
281 }
282 LISTBASE_FOREACH (LineStyleModifier *, m, modifiers) {
283 switch (m->type) {
286 break;
290 break;
294 break;
297 break;
300 break;
303 break;
306 break;
309 break;
310 }
311 }
312}
313
315{
316 LISTBASE_FOREACH (LineStyleModifier *, m, modifiers) {
317 int struct_nr;
318 switch (m->type) {
321 break;
324 break;
327 break;
330 break;
333 break;
336 break;
339 break;
342 break;
345 break;
346 default:
347 struct_nr = sdna_struct_id_get<LineStyleModifier>(); /* this should not happen */
348 }
349 BLO_write_struct_by_id(writer, struct_nr, m);
350 }
351 LISTBASE_FOREACH (LineStyleModifier *, m, modifiers) {
352 switch (m->type) {
355 break;
359 break;
363 break;
366 break;
369 break;
372 break;
376 break;
377 }
378 }
379}
380
382{
383 LISTBASE_FOREACH (LineStyleModifier *, m, modifiers) {
384 int struct_nr;
385 switch (m->type) {
388 break;
391 break;
394 break;
397 break;
400 break;
403 break;
406 break;
409 break;
412 break;
415 break;
418 break;
421 break;
424 break;
427 break;
428 default:
429 struct_nr = sdna_struct_id_get<LineStyleModifier>(); /* this should not happen */
430 }
431 BLO_write_struct_by_id(writer, struct_nr, m);
432 }
433}
434
435static void linestyle_blend_write(BlendWriter *writer, ID *id, const void *id_address)
436{
437 FreestyleLineStyle *linestyle = (FreestyleLineStyle *)id;
438
439 BLO_write_id_struct(writer, FreestyleLineStyle, id_address, &linestyle->id);
440 BKE_id_blend_write(writer, &linestyle->id);
441
446 for (int a = 0; a < MAX_MTEX; a++) {
447 if (linestyle->mtex[a]) {
448 BLO_write_struct(writer, MTex, linestyle->mtex[a]);
449 }
450 }
451 if (linestyle->nodetree) {
452 BLO_Write_IDBuffer temp_embedded_id_buffer{linestyle->nodetree->id, writer};
454 writer, bNodeTree, linestyle->nodetree, temp_embedded_id_buffer.get());
456 writer, reinterpret_cast<bNodeTree *>(temp_embedded_id_buffer.get()));
457 }
458}
459
461 LineStyleModifier *modifier)
462{
463 switch (modifier->type) {
467 break;
468 }
471 modifier;
473 break;
474 }
477 modifier;
479 break;
480 }
484 break;
485 }
486 case LS_MODIFIER_TANGENT: {
489 break;
490 }
491 case LS_MODIFIER_NOISE: {
494 break;
495 }
499 break;
500 }
504 break;
505 }
506 }
507}
508
510 LineStyleModifier *modifier)
511{
512 switch (modifier->type) {
515 BLO_read_struct(reader, CurveMapping, &m->curve);
517 break;
518 }
521 modifier;
522 BLO_read_struct(reader, CurveMapping, &m->curve);
524 break;
525 }
528 modifier;
529 BLO_read_struct(reader, CurveMapping, &m->curve);
531 break;
532 }
535 BLO_read_struct(reader, CurveMapping, &m->curve);
537 break;
538 }
539 case LS_MODIFIER_TANGENT: {
541 BLO_read_struct(reader, CurveMapping, &m->curve);
543 break;
544 }
545 case LS_MODIFIER_NOISE: {
547 BLO_read_struct(reader, CurveMapping, &m->curve);
549 break;
550 }
553 BLO_read_struct(reader, CurveMapping, &m->curve);
555 break;
556 }
559 BLO_read_struct(reader, CurveMapping, &m->curve);
561 break;
562 }
563 }
564}
565
567 LineStyleModifier *modifier)
568{
569 switch (modifier->type) {
572 modifier;
573 BLO_read_struct(reader, CurveMapping, &m->curve);
575 break;
576 }
580 BLO_read_struct(reader, CurveMapping, &m->curve);
582 break;
583 }
587 BLO_read_struct(reader, CurveMapping, &m->curve);
589 break;
590 }
593 BLO_read_struct(reader, CurveMapping, &m->curve);
595 break;
596 }
597 case LS_MODIFIER_TANGENT: {
599 BLO_read_struct(reader, CurveMapping, &m->curve);
601 break;
602 }
605 modifier;
606 BLO_read_struct(reader, CurveMapping, &m->curve);
608 break;
609 }
612 modifier;
613 BLO_read_struct(reader, CurveMapping, &m->curve);
615 break;
616 }
617 }
618}
619
621 LineStyleModifier * /*modifier*/)
622{
623}
624
625static size_t color_modifier_struct_size(int type);
626static size_t alpha_modifier_struct_size(int type);
627static size_t thickness_modifier_struct_size(int type);
628static size_t geometry_modifier_struct_size(int type);
629
631 ListBase *modifiers,
632 size_t (*struct_size)(int))
633{
635 reader, modifiers, [&](const LineStyleModifier &modifier) {
636 return std::max(struct_size(modifier.type), sizeof(LineStyleModifier));
637 });
638}
639
641{
642 FreestyleLineStyle *linestyle = (FreestyleLineStyle *)id;
643
645 LISTBASE_FOREACH (LineStyleModifier *, modifier, &linestyle->color_modifiers) {
646 direct_link_linestyle_color_modifier(reader, modifier);
647 }
649 LISTBASE_FOREACH (LineStyleModifier *, modifier, &linestyle->alpha_modifiers) {
650 direct_link_linestyle_alpha_modifier(reader, modifier);
651 }
654 LISTBASE_FOREACH (LineStyleModifier *, modifier, &linestyle->thickness_modifiers) {
656 }
658 LISTBASE_FOREACH (LineStyleModifier *, modifier, &linestyle->geometry_modifiers) {
660 }
661 for (int a = 0; a < MAX_MTEX; a++) {
662 BLO_read_struct(reader, MTex, &linestyle->mtex[a]);
663 }
664}
665
667 /*id_code*/ FreestyleLineStyle::id_type,
668 /*id_filter*/ FILTER_ID_LS,
669 /*dependencies_id_types*/ FILTER_ID_TE | FILTER_ID_OB,
670 /*main_listbase_index*/ INDEX_ID_LS,
671 /*struct_size*/ sizeof(FreestyleLineStyle),
672 /*name*/ "FreestyleLineStyle",
673 /*name_plural*/ N_("linestyles"),
674 /*translation_context*/ BLT_I18NCONTEXT_ID_FREESTYLELINESTYLE,
676 /*asset_type_info*/ nullptr,
677
678 /*init_data*/ linestyle_init_data,
679 /*copy_data*/ linestyle_copy_data,
680 /*free_data*/ linestyle_free_data,
681 /*make_local*/ nullptr,
682 /*foreach_id*/ linestyle_foreach_id,
683 /*foreach_cache*/ nullptr,
684 /*foreach_path*/ nullptr,
685 /*owner_pointer_get*/ nullptr,
686
687 /*blend_write*/ linestyle_blend_write,
688 /*blend_read_data*/ linestyle_blend_read_data,
689 /*blend_read_after_liblink*/ nullptr,
690
691 /*blend_read_undo_preserve*/ nullptr,
692
693 /*lib_override_apply_post*/ nullptr,
694};
695
696static const char *modifier_name[LS_MODIFIER_NUM] = {
697 nullptr, "Along Stroke", "Distance from Camera", "Distance from Object",
698 "Material", "Sampling", "Bézier Curve", "Sinus Displacement",
699 "Spatial Noise", "Perlin Noise 1D", "Perlin Noise 2D", "Backbone Stretcher",
700 "Tip Remover", "Calligraphy", "Polygonalization", "Guiding Lines",
701 "Blueprint", "2D Offset", "2D Transform", "Tangent",
702 "Noise", "Crease Angle", "Simplification", "Curvature 3D",
703};
704
706{
707 linestyle_init_data(&linestyle->id);
708}
709
710FreestyleLineStyle *BKE_linestyle_new(Main *bmain, const char *name)
711{
712 FreestyleLineStyle *linestyle;
713
714 linestyle = (FreestyleLineStyle *)BKE_libblock_alloc(bmain, ID_LS, name, 0);
715
716 BKE_linestyle_init(linestyle);
717
718 return linestyle;
719}
720
722{
723 FreestyleConfig *config = &view_layer->freestyle_config;
725 return (lineset) ? lineset->linestyle : nullptr;
726}
727
728static LineStyleModifier *new_modifier(const char *name, int type, size_t size)
729{
731
732 if (!name) {
733 name = modifier_name[type];
734 }
735 m = (LineStyleModifier *)MEM_callocN(size, "line style modifier");
736 m->type = type;
737 STRNCPY(m->name, DATA_(name));
738 m->influence = 1.0f;
740
741 return m;
742}
743
745{
746 BLI_addtail(lb, (void *)m);
748 lb, m, modifier_name[m->type], '.', offsetof(LineStyleModifier, name), sizeof(m->name));
749}
750
751static size_t color_modifier_struct_size(const int type)
752{
753 switch (type) {
761 return sizeof(LineStyleColorModifier_Material);
763 return sizeof(LineStyleColorModifier_Tangent);
765 return sizeof(LineStyleColorModifier_Noise);
770 default:
771 return 0; /* unknown modifier type */
772 }
773}
774
775static LineStyleModifier *alloc_color_modifier(const char *name, int type)
776{
777 const size_t size = color_modifier_struct_size(type);
778 if (size == 0) {
779 return nullptr;
780 }
781 return new_modifier(name, type, size);
782}
783
785 const char *name,
786 int type)
787{
789
790 m = alloc_color_modifier(name, type);
791 if (UNLIKELY(m == nullptr)) {
792 return nullptr;
793 }
794 m->blend = MA_RAMP_BLEND;
795
796 switch (type) {
798 ((LineStyleColorModifier_AlongStroke *)m)->color_ramp = BKE_colorband_add(true);
799 break;
802 ((LineStyleColorModifier_DistanceFromCamera *)m)->range_min = 0.0f;
803 ((LineStyleColorModifier_DistanceFromCamera *)m)->range_max = 10000.0f;
804 break;
806 ((LineStyleColorModifier_DistanceFromObject *)m)->target = nullptr;
808 ((LineStyleColorModifier_DistanceFromObject *)m)->range_min = 0.0f;
809 ((LineStyleColorModifier_DistanceFromObject *)m)->range_max = 10000.0f;
810 break;
812 ((LineStyleColorModifier_Material *)m)->color_ramp = BKE_colorband_add(true);
814 break;
816 ((LineStyleColorModifier_Tangent *)m)->color_ramp = BKE_colorband_add(true);
817 break;
819 ((LineStyleColorModifier_Noise *)m)->color_ramp = BKE_colorband_add(true);
820 ((LineStyleColorModifier_Noise *)m)->amplitude = 10.0f;
821 ((LineStyleColorModifier_Noise *)m)->period = 10.0f;
822 ((LineStyleColorModifier_Noise *)m)->seed = 512;
823 break;
825 ((LineStyleColorModifier_CreaseAngle *)m)->color_ramp = BKE_colorband_add(true);
826 ((LineStyleColorModifier_CreaseAngle *)m)->min_angle = 0.0f;
827 ((LineStyleColorModifier_CreaseAngle *)m)->max_angle = DEG2RADF(180.0f);
828 break;
831 ((LineStyleColorModifier_Curvature_3D *)m)->min_curvature = 0.0f;
832 ((LineStyleColorModifier_Curvature_3D *)m)->max_curvature = 0.5f;
833 break;
834 default:
835 return nullptr; /* unknown modifier type */
836 }
838
839 return m;
840}
841
843 const LineStyleModifier *m,
844 const int flag)
845{
846 LineStyleModifier *new_m;
847
848 new_m = alloc_color_modifier(m->name, m->type);
849 if (UNLIKELY(new_m == nullptr)) {
850 return nullptr;
851 }
852 new_m->influence = m->influence;
853 new_m->flags = m->flags;
854 new_m->blend = m->blend;
855
856 switch (m->type) {
860 q->color_ramp = static_cast<ColorBand *>(MEM_dupallocN(p->color_ramp));
861 break;
862 }
865 m;
867 new_m;
868 q->color_ramp = static_cast<ColorBand *>(MEM_dupallocN(p->color_ramp));
869 q->range_min = p->range_min;
870 q->range_max = p->range_max;
871 break;
872 }
875 m;
877 new_m;
878 q->target = p->target;
879 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
880 id_us_plus((ID *)q->target);
881 }
882 q->color_ramp = static_cast<ColorBand *>(MEM_dupallocN(p->color_ramp));
883 q->range_min = p->range_min;
884 q->range_max = p->range_max;
885 break;
886 }
890 q->color_ramp = static_cast<ColorBand *>(MEM_dupallocN(p->color_ramp));
891 q->flags = p->flags;
892 q->mat_attr = p->mat_attr;
893 break;
894 }
895 case LS_MODIFIER_TANGENT: {
898 q->color_ramp = static_cast<ColorBand *>(MEM_dupallocN(p->color_ramp));
899 break;
900 }
901 case LS_MODIFIER_NOISE: {
904 q->color_ramp = static_cast<ColorBand *>(MEM_dupallocN(p->color_ramp));
905 q->amplitude = p->amplitude;
906 q->period = p->period;
907 q->seed = p->seed;
908 break;
909 }
913 q->color_ramp = static_cast<ColorBand *>(MEM_dupallocN(p->color_ramp));
914 q->min_angle = p->min_angle;
915 q->max_angle = p->max_angle;
916 break;
917 }
921 q->color_ramp = static_cast<ColorBand *>(MEM_dupallocN(p->color_ramp));
924 break;
925 }
926 default:
927 return nullptr; /* unknown modifier type */
928 }
929 add_to_modifier_list(&linestyle->color_modifiers, new_m);
930
931 return new_m;
932}
933
935{
936 if (BLI_findindex(&linestyle->color_modifiers, m) == -1) {
937 return -1;
938 }
939 switch (m->type) {
942 break;
945 break;
948 break;
950 MEM_freeN(((LineStyleColorModifier_Material *)m)->color_ramp);
951 break;
953 MEM_freeN(((LineStyleColorModifier_Tangent *)m)->color_ramp);
954 break;
956 MEM_freeN(((LineStyleColorModifier_Noise *)m)->color_ramp);
957 break;
960 break;
963 break;
964 }
965 BLI_freelinkN(&linestyle->color_modifiers, m);
966 return 0;
967}
968
969static size_t alpha_modifier_struct_size(const int type)
970{
971 switch (type) {
979 return sizeof(LineStyleAlphaModifier_Material);
981 return sizeof(LineStyleAlphaModifier_Tangent);
983 return sizeof(LineStyleAlphaModifier_Noise);
988 default:
989 return 0; /* unknown modifier type */
990 }
991}
992
993static LineStyleModifier *alloc_alpha_modifier(const char *name, int type)
994{
995 const size_t size = alpha_modifier_struct_size(type);
996 if (size == 0) {
997 return nullptr;
998 }
999 return new_modifier(name, type, size);
1000}
1001
1003 const char *name,
1004 int type)
1005{
1007
1008 m = alloc_alpha_modifier(name, type);
1009 m->blend = LS_VALUE_BLEND;
1010
1011 switch (type) {
1014 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1015 break;
1016 }
1019 m;
1020 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1021 p->range_min = 0.0f;
1022 p->range_max = 10000.0f;
1023 break;
1024 }
1027 m;
1028 p->target = nullptr;
1029 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1030 p->range_min = 0.0f;
1031 p->range_max = 10000.0f;
1032 break;
1033 }
1034 case LS_MODIFIER_MATERIAL: {
1036 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1038 break;
1039 }
1040 case LS_MODIFIER_TANGENT: {
1042 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1043 break;
1044 }
1045 case LS_MODIFIER_NOISE: {
1047 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1048 ((LineStyleAlphaModifier_Noise *)m)->amplitude = 10.0f;
1049 ((LineStyleAlphaModifier_Noise *)m)->period = 10.0f;
1050 ((LineStyleAlphaModifier_Noise *)m)->seed = 512;
1051 break;
1052 }
1055 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1056 ((LineStyleAlphaModifier_CreaseAngle *)m)->min_angle = 0.0f;
1057 ((LineStyleAlphaModifier_CreaseAngle *)m)->max_angle = DEG2RADF(180.0f);
1058 break;
1059 }
1062 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1063 ((LineStyleAlphaModifier_Curvature_3D *)m)->min_curvature = 0.0f;
1064 ((LineStyleAlphaModifier_Curvature_3D *)m)->max_curvature = 0.5f;
1065 break;
1066 }
1067 default:
1068 return nullptr; /* unknown modifier type */
1069 }
1070 add_to_modifier_list(&linestyle->alpha_modifiers, m);
1071
1072 return m;
1073}
1074
1076 const LineStyleModifier *m,
1077 const int /*flag*/)
1078{
1079 LineStyleModifier *new_m;
1080
1081 new_m = alloc_alpha_modifier(m->name, m->type);
1082 if (new_m == nullptr) [[unlikely]] {
1083 return nullptr;
1084 }
1085 new_m->influence = m->influence;
1086 new_m->flags = m->flags;
1087 new_m->blend = m->blend;
1088
1089 switch (m->type) {
1094 q->flags = p->flags;
1095 break;
1096 }
1099 m;
1101 new_m;
1103 q->flags = p->flags;
1104 q->range_min = p->range_min;
1105 q->range_max = p->range_max;
1106 break;
1107 }
1110 m;
1112 new_m;
1113 if (p->target) {
1114 id_us_plus(&p->target->id);
1115 }
1116 q->target = p->target;
1118 q->flags = p->flags;
1119 q->range_min = p->range_min;
1120 q->range_max = p->range_max;
1121 break;
1122 }
1123 case LS_MODIFIER_MATERIAL: {
1127 q->flags = p->flags;
1128 q->mat_attr = p->mat_attr;
1129 break;
1130 }
1131 case LS_MODIFIER_TANGENT: {
1135 q->flags = p->flags;
1136 break;
1137 }
1138 case LS_MODIFIER_NOISE: {
1142 q->flags = p->flags;
1143 q->amplitude = p->amplitude;
1144 q->period = p->period;
1145 q->seed = p->seed;
1146 break;
1147 }
1152 q->flags = p->flags;
1153 q->min_angle = p->min_angle;
1154 q->max_angle = p->max_angle;
1155 break;
1156 }
1161 q->flags = p->flags;
1164 break;
1165 }
1166 default:
1167 return nullptr; /* unknown modifier type */
1168 }
1169 add_to_modifier_list(&linestyle->alpha_modifiers, new_m);
1170
1171 return new_m;
1172}
1173
1175{
1176 if (BLI_findindex(&linestyle->alpha_modifiers, m) == -1) {
1177 return -1;
1178 }
1179 switch (m->type) {
1182 break;
1185 break;
1188 break;
1191 break;
1194 break;
1195 case LS_MODIFIER_NOISE:
1197 break;
1200 break;
1203 break;
1204 }
1205 BLI_freelinkN(&linestyle->alpha_modifiers, m);
1206 return 0;
1207}
1208
1209static size_t thickness_modifier_struct_size(const int type)
1210{
1211 switch (type) {
1224 case LS_MODIFIER_NOISE:
1225 return sizeof(LineStyleThicknessModifier_Noise);
1230 default:
1231 return 0; /* unknown modifier type */
1232 }
1233}
1234
1235static LineStyleModifier *alloc_thickness_modifier(const char *name, int type)
1236{
1237 const size_t size = thickness_modifier_struct_size(type);
1238 if (size == 0) {
1239 return nullptr;
1240 }
1241 return new_modifier(name, type, size);
1242}
1243
1245 const char *name,
1246 int type)
1247{
1249
1250 m = alloc_thickness_modifier(name, type);
1251 m->blend = LS_VALUE_BLEND;
1252
1253 switch (type) {
1256 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1257 p->value_min = 0.0f;
1258 p->value_max = 1.0f;
1259 break;
1260 }
1264 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1265 p->range_min = 0.0f;
1266 p->range_max = 1000.0f;
1267 p->value_min = 0.0f;
1268 p->value_max = 1.0f;
1269 break;
1270 }
1274 p->target = nullptr;
1275 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1276 p->range_min = 0.0f;
1277 p->range_max = 1000.0f;
1278 p->value_min = 0.0f;
1279 p->value_max = 1.0f;
1280 break;
1281 }
1282 case LS_MODIFIER_MATERIAL: {
1284 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1286 p->value_min = 0.0f;
1287 p->value_max = 1.0f;
1288 break;
1289 }
1292 p->min_thickness = 1.0f;
1293 p->max_thickness = 10.0f;
1294 p->orientation = DEG2RADF(60.0f);
1295 break;
1296 }
1297 case LS_MODIFIER_TANGENT: {
1299 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1300 p->min_thickness = 1.0f;
1301 p->max_thickness = 10.0f;
1302 break;
1303 }
1304 case LS_MODIFIER_NOISE: {
1306 p->period = 10.0f;
1307 p->amplitude = 10.0f;
1308 p->seed = 512;
1310 break;
1311 }
1314 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1315 p->min_angle = 0.0f;
1316 p->max_angle = DEG2RADF(180.0f);
1317 p->min_thickness = 1.0f;
1318 p->max_thickness = 10.0f;
1319 break;
1320 }
1323 p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1324 p->min_curvature = 0.0f;
1325 p->max_curvature = 0.5f;
1326 p->min_thickness = 1.0f;
1327 p->max_thickness = 10.0f;
1328 break;
1329 }
1330 default:
1331 return nullptr; /* unknown modifier type */
1332 }
1334
1335 return m;
1336}
1337
1339 const LineStyleModifier *m,
1340 const int flag)
1341{
1342 LineStyleModifier *new_m;
1343
1344 new_m = alloc_thickness_modifier(m->name, m->type);
1345 if (!new_m) {
1346 return nullptr;
1347 }
1348 new_m->influence = m->influence;
1349 new_m->flags = m->flags;
1350 new_m->blend = m->blend;
1351
1352 switch (m->type) {
1357 q->flags = p->flags;
1358 q->value_min = p->value_min;
1359 q->value_max = p->value_max;
1360 break;
1361 }
1368 q->flags = p->flags;
1369 q->range_min = p->range_min;
1370 q->range_max = p->range_max;
1371 q->value_min = p->value_min;
1372 q->value_max = p->value_max;
1373 break;
1374 }
1380 q->target = p->target;
1381 if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
1382 id_us_plus((ID *)q->target);
1383 }
1385 q->flags = p->flags;
1386 q->range_min = p->range_min;
1387 q->range_max = p->range_max;
1388 q->value_min = p->value_min;
1389 q->value_max = p->value_max;
1390 break;
1391 }
1392 case LS_MODIFIER_MATERIAL: {
1396 q->flags = p->flags;
1397 q->mat_attr = p->mat_attr;
1398 q->value_min = p->value_min;
1399 q->value_max = p->value_max;
1400 break;
1401 }
1407 q->orientation = p->orientation;
1408 break;
1409 }
1410 case LS_MODIFIER_TANGENT: {
1414 q->flags = p->flags;
1417 break;
1418 }
1419 case LS_MODIFIER_NOISE: {
1422 q->amplitude = p->amplitude;
1423 q->period = p->period;
1424 q->seed = p->seed;
1425 q->flags = p->flags;
1426 break;
1427 }
1431 new_m;
1433 q->flags = p->flags;
1438 break;
1439 }
1444 q->flags = p->flags;
1445 q->min_angle = p->min_angle;
1446 q->max_angle = p->max_angle;
1449 break;
1450 }
1451 default:
1452 return nullptr; /* unknown modifier type */
1453 }
1454 add_to_modifier_list(&linestyle->thickness_modifiers, new_m);
1455
1456 return new_m;
1457}
1458
1460{
1461 if (BLI_findindex(&linestyle->thickness_modifiers, m) == -1) {
1462 return -1;
1463 }
1464 switch (m->type) {
1467 break;
1470 break;
1473 break;
1476 break;
1478 break;
1481 break;
1482 case LS_MODIFIER_NOISE:
1483 break;
1485 break;
1487 break;
1488 }
1489 BLI_freelinkN(&linestyle->thickness_modifiers, m);
1490 return 0;
1491}
1492
1493static size_t geometry_modifier_struct_size(const int type)
1494{
1495 switch (type) {
1524 default:
1525 return 0; /* unknown modifier type */
1526 }
1527}
1528
1529static LineStyleModifier *alloc_geometry_modifier(const char *name, int type)
1530{
1531 const size_t size = geometry_modifier_struct_size(type);
1532 if (size == 0) {
1533 return nullptr;
1534 }
1535 return new_modifier(name, type, size);
1536}
1537
1539 const char *name,
1540 int type)
1541{
1543
1544 m = alloc_geometry_modifier(name, type);
1545
1546 switch (type) {
1547 case LS_MODIFIER_SAMPLING: {
1549 p->sampling = 10.0f;
1550 break;
1551 }
1554 p->error = 10.0f;
1555 break;
1556 }
1560 p->wavelength = 20.0f;
1561 p->amplitude = 5.0f;
1562 p->phase = 0.0f;
1563 break;
1564 }
1567 p->amplitude = 5.0f;
1568 p->scale = 20.0f;
1569 p->octaves = 4;
1571 break;
1572 }
1575 p->frequency = 10.0f;
1576 p->amplitude = 10.0f;
1577 p->octaves = 4;
1578 p->angle = DEG2RADF(45.0f);
1579 break;
1580 }
1583 p->frequency = 10.0f;
1584 p->amplitude = 10.0f;
1585 p->octaves = 4;
1586 p->angle = DEG2RADF(45.0f);
1587 break;
1588 }
1592 p->backbone_length = 10.0f;
1593 break;
1594 }
1597 p->tip_length = 10.0f;
1598 break;
1599 }
1603 p->error = 10.0f;
1604 break;
1605 }
1608 p->offset = 0.0f;
1609 break;
1610 }
1611 case LS_MODIFIER_BLUEPRINT: {
1614 p->rounds = 1;
1615 p->backbone_length = 10.0f;
1616 p->random_radius = 3;
1617 p->random_center = 5;
1618 p->random_backbone = 5;
1619 break;
1620 }
1621 case LS_MODIFIER_2D_OFFSET: {
1623 p->start = 0.0f;
1624 p->end = 0.0f;
1625 p->x = 0.0f;
1626 p->y = 0.0f;
1627 break;
1628 }
1632 p->scale_x = 1.0f;
1633 p->scale_y = 1.0f;
1634 p->angle = DEG2RADF(0.0f);
1635 p->pivot_u = 0.5f;
1636 p->pivot_x = 0.0f;
1637 p->pivot_y = 0.0f;
1638 break;
1639 }
1642 p->tolerance = 0.1f;
1643 break;
1644 }
1645 default:
1646 return nullptr; /* unknown modifier type */
1647 }
1649
1650 return m;
1651}
1652
1654 const LineStyleModifier *m,
1655 const int /*flag*/)
1656{
1657 LineStyleModifier *new_m;
1658
1659 new_m = alloc_geometry_modifier(m->name, m->type);
1660 if (new_m == nullptr) [[unlikely]] {
1661 return nullptr;
1662 }
1663 new_m->flags = m->flags;
1664
1665 switch (m->type) {
1666 case LS_MODIFIER_SAMPLING: {
1669 q->sampling = p->sampling;
1670 break;
1671 }
1675 q->error = p->error;
1676 break;
1677 }
1683 q->wavelength = p->wavelength;
1684 q->amplitude = p->amplitude;
1685 q->phase = p->phase;
1686 break;
1687 }
1691 q->amplitude = p->amplitude;
1692 q->scale = p->scale;
1693 q->octaves = p->octaves;
1694 q->flags = p->flags;
1695 break;
1696 }
1700 new_m;
1701 q->frequency = p->frequency;
1702 q->amplitude = p->amplitude;
1703 q->angle = p->angle;
1704 q->octaves = p->octaves;
1705 q->seed = p->seed;
1706 break;
1707 }
1711 new_m;
1712 q->frequency = p->frequency;
1713 q->amplitude = p->amplitude;
1714 q->angle = p->angle;
1715 q->octaves = p->octaves;
1716 q->seed = p->seed;
1717 break;
1718 }
1725 break;
1726 }
1730 q->tip_length = p->tip_length;
1731 break;
1732 }
1738 q->error = p->error;
1739 break;
1740 }
1744 q->offset = p->offset;
1745 break;
1746 }
1747 case LS_MODIFIER_BLUEPRINT: {
1750 q->flags = p->flags;
1751 q->rounds = p->rounds;
1756 break;
1757 }
1758 case LS_MODIFIER_2D_OFFSET: {
1761 q->start = p->start;
1762 q->end = p->end;
1763 q->x = p->x;
1764 q->y = p->y;
1765 break;
1766 }
1770 q->pivot = p->pivot;
1771 q->scale_x = p->scale_x;
1772 q->scale_y = p->scale_y;
1773 q->angle = p->angle;
1774 q->pivot_u = p->pivot_u;
1775 q->pivot_x = p->pivot_x;
1776 q->pivot_y = p->pivot_y;
1777 break;
1778 }
1782 new_m;
1783 q->tolerance = p->tolerance;
1784 break;
1785 }
1786 default:
1787 return nullptr; /* unknown modifier type */
1788 }
1789 add_to_modifier_list(&linestyle->geometry_modifiers, new_m);
1790
1791 return new_m;
1792}
1793
1795{
1796 if (BLI_findindex(&linestyle->geometry_modifiers, m) == -1) {
1797 return -1;
1798 }
1799 BLI_freelinkN(&linestyle->geometry_modifiers, m);
1800 return 0;
1801}
1802
1804 LineStyleModifier *modifier,
1805 int direction)
1806{
1807 return BLI_listbase_link_move(&linestyle->color_modifiers, modifier, direction);
1808}
1810 LineStyleModifier *modifier,
1811 int direction)
1812{
1813 return BLI_listbase_link_move(&linestyle->alpha_modifiers, modifier, direction);
1814}
1816 LineStyleModifier *modifier,
1817 int direction)
1818{
1819 return BLI_listbase_link_move(&linestyle->thickness_modifiers, modifier, direction);
1820}
1822 LineStyleModifier *modifier,
1823 int direction)
1824{
1825 return BLI_listbase_link_move(&linestyle->geometry_modifiers, modifier, direction);
1826}
1827
1829{
1830 ColorBand *color_ramp;
1831 LinkData *link;
1832
1833 BLI_listbase_clear(listbase);
1834
1836 switch (m->type) {
1838 color_ramp = ((LineStyleColorModifier_AlongStroke *)m)->color_ramp;
1839 break;
1841 color_ramp = ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp;
1842 break;
1844 color_ramp = ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp;
1845 break;
1847 color_ramp = ((LineStyleColorModifier_Material *)m)->color_ramp;
1848 break;
1849 default:
1850 continue;
1851 }
1852 link = MEM_callocN<LinkData>("link to color ramp");
1853 link->data = color_ramp;
1854 BLI_addtail(listbase, link);
1855 }
1856}
1857
1858std::optional<std::string> BKE_linestyle_path_to_color_ramp(FreestyleLineStyle *linestyle,
1859 const ColorBand *color_ramp)
1860{
1861 bool found = false;
1862
1864 switch (m->type) {
1866 if (color_ramp == ((LineStyleColorModifier_AlongStroke *)m)->color_ramp) {
1867 found = true;
1868 }
1869 break;
1871 if (color_ramp == ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp) {
1872 found = true;
1873 }
1874 break;
1876 if (color_ramp == ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp) {
1877 found = true;
1878 }
1879 break;
1881 if (color_ramp == ((LineStyleColorModifier_Material *)m)->color_ramp) {
1882 found = true;
1883 }
1884 break;
1886 if (color_ramp == ((LineStyleColorModifier_Tangent *)m)->color_ramp) {
1887 found = true;
1888 }
1889 break;
1890 case LS_MODIFIER_NOISE:
1891 if (color_ramp == ((LineStyleColorModifier_Noise *)m)->color_ramp) {
1892 found = true;
1893 }
1894 break;
1896 if (color_ramp == ((LineStyleColorModifier_CreaseAngle *)m)->color_ramp) {
1897 found = true;
1898 }
1899 break;
1901 if (color_ramp == ((LineStyleColorModifier_Curvature_3D *)m)->color_ramp) {
1902 found = true;
1903 }
1904 break;
1905 }
1906
1907 if (found) {
1908 char name_esc[sizeof(m->name) * 2];
1909 BLI_str_escape(name_esc, m->name, sizeof(name_esc));
1910 return fmt::format("color_modifiers[\"{}\"].color_ramp", name_esc);
1911 }
1912 }
1913 printf("BKE_linestyle_path_to_color_ramp: No color ramps correspond to the given pointer.\n");
1914 return std::nullopt;
1915}
1916
1917bool BKE_linestyle_use_textures(FreestyleLineStyle *linestyle, const bool use_shading_nodes)
1918{
1919 if (use_shading_nodes) {
1920 if (linestyle && linestyle->use_nodes && linestyle->nodetree) {
1921 LISTBASE_FOREACH (bNode *, node, &linestyle->nodetree->nodes) {
1922 if (node->typeinfo->nclass == NODE_CLASS_TEXTURE) {
1923 return true;
1924 }
1925 }
1926 }
1927 }
1928 else {
1929 if (linestyle && (linestyle->flag & LS_TEXTURE)) {
1930 return (linestyle->mtex[0] != nullptr);
1931 }
1932 }
1933 return false;
1934}
1935
1937{
1938 bNode *uv_along_stroke, *input_texture, *output_linestyle;
1939 bNodeSocket *fromsock, *tosock;
1940 bNodeTree *ntree;
1941
1942 BLI_assert(linestyle->nodetree == nullptr);
1943
1945 nullptr, &linestyle->id, "stroke_shader", "ShaderNodeTree");
1946
1948 uv_along_stroke->location[0] = -200.0f;
1949 uv_along_stroke->location[1] = 100.0f;
1950 uv_along_stroke->custom1 = 0; /* use_tips */
1951
1952 input_texture = blender::bke::node_add_static_node(C, *ntree, SH_NODE_TEX_IMAGE);
1953 input_texture->location[0] = 0.0f;
1954 input_texture->location[1] = 100.0f;
1955
1957 output_linestyle->location[0] = 300.0f;
1958 output_linestyle->location[1] = 100.0f;
1959 output_linestyle->custom1 = MA_RAMP_BLEND;
1960 output_linestyle->custom2 = 0; /* use_clamp */
1961
1962 blender::bke::node_set_active(*ntree, *input_texture);
1963
1964 fromsock = static_cast<bNodeSocket *>(BLI_findlink(&uv_along_stroke->outputs, 0)); /* UV */
1965 tosock = static_cast<bNodeSocket *>(BLI_findlink(&input_texture->inputs, 0)); /* UV */
1966 blender::bke::node_add_link(*ntree, *uv_along_stroke, *fromsock, *input_texture, *tosock);
1967
1968 fromsock = static_cast<bNodeSocket *>(BLI_findlink(&input_texture->outputs, 0)); /* Color */
1969 tosock = static_cast<bNodeSocket *>(BLI_findlink(&output_linestyle->inputs, 0)); /* Color */
1970 blender::bke::node_add_link(*ntree, *input_texture, *fromsock, *output_linestyle, *tosock);
1971
1973}
ColorBand * BKE_colorband_add(bool rangetype)
Definition colorband.cc:297
void BKE_curvemapping_blend_read(BlendDataReader *reader, CurveMapping *cumap)
CurveMapping * BKE_curvemapping_copy(const CurveMapping *cumap)
CurveMapping * BKE_curvemapping_add(int tot, float minx, float miny, float maxx, float maxy)
Definition colortools.cc:89
void BKE_curvemapping_free(CurveMapping *cumap)
void BKE_curvemapping_blend_write(BlendWriter *writer, const CurveMapping *cumap)
Main * CTX_data_main(const bContext *C)
struct FreestyleLineSet * BKE_freestyle_lineset_get_active(struct FreestyleConfig *config)
Definition freestyle.cc:212
@ IDTYPE_FLAGS_APPEND_IS_REUSABLE
Definition BKE_idtype.hh:44
IDTypeInfo IDType_ID_LS
Definition linestyle.cc:666
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:663
void * BKE_libblock_alloc(Main *bmain, short type, const char *name, int flag) ATTR_WARN_UNUSED_RESULT
Definition lib_id.cc:1428
void id_us_plus(ID *id)
Definition lib_id.cc:353
@ LIB_ID_CREATE_NO_ALLOCATE
@ LIB_ID_CREATE_NO_USER_REFCOUNT
void BKE_id_blend_write(BlendWriter *writer, ID *id)
Definition lib_id.cc:2611
#define BKE_LIB_FOREACHID_PROCESS_FUNCTION_CALL(data_, func_call_)
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER(data_, id_super_, cb_flag_)
void BKE_library_foreach_ID_embedded(LibraryForeachIDData *data, ID **id_pp)
Definition lib_query.cc:172
@ IDWALK_CB_NOP
Blender kernel freestyle line style functionality.
FreestyleLineStyle * BKE_linestyle_new(struct Main *bmain, const char *name)
Definition linestyle.cc:710
int BKE_linestyle_alpha_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *modifier)
int BKE_linestyle_color_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *modifier)
Definition linestyle.cc:934
void BKE_linestyle_modifier_list_color_ramps(FreestyleLineStyle *linestyle, ListBase *listbase)
LineStyleModifier * BKE_linestyle_geometry_modifier_copy(FreestyleLineStyle *linestyle, const LineStyleModifier *m, int flag)
LineStyleModifier * BKE_linestyle_thickness_modifier_copy(FreestyleLineStyle *linestyle, const LineStyleModifier *m, int flag)
bool BKE_linestyle_thickness_modifier_move(FreestyleLineStyle *linestyle, LineStyleModifier *modifier, int direction)
LineStyleModifier * BKE_linestyle_geometry_modifier_add(FreestyleLineStyle *linestyle, const char *name, int type)
bool BKE_linestyle_color_modifier_move(FreestyleLineStyle *linestyle, LineStyleModifier *modifier, int direction)
void BKE_linestyle_default_shader(const struct bContext *C, FreestyleLineStyle *linestyle)
LineStyleModifier * BKE_linestyle_alpha_modifier_add(FreestyleLineStyle *linestyle, const char *name, int type)
FreestyleLineStyle * BKE_linestyle_active_from_view_layer(struct ViewLayer *view_layer)
Definition linestyle.cc:721
LineStyleModifier * BKE_linestyle_color_modifier_add(FreestyleLineStyle *linestyle, const char *name, int type)
Definition linestyle.cc:784
std::optional< std::string > BKE_linestyle_path_to_color_ramp(FreestyleLineStyle *linestyle, const struct ColorBand *color_ramp)
int BKE_linestyle_thickness_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *modifier)
bool BKE_linestyle_alpha_modifier_move(FreestyleLineStyle *linestyle, LineStyleModifier *modifier, int direction)
bool BKE_linestyle_geometry_modifier_move(FreestyleLineStyle *linestyle, LineStyleModifier *modifier, int direction)
LineStyleModifier * BKE_linestyle_color_modifier_copy(FreestyleLineStyle *linestyle, const LineStyleModifier *m, int flag)
Definition linestyle.cc:842
bool BKE_linestyle_use_textures(FreestyleLineStyle *linestyle, bool use_shading_nodes)
void BKE_linestyle_init(struct FreestyleLineStyle *linestyle)
Definition linestyle.cc:705
LineStyleModifier * BKE_linestyle_thickness_modifier_add(FreestyleLineStyle *linestyle, const char *name, int type)
LineStyleModifier * BKE_linestyle_alpha_modifier_copy(FreestyleLineStyle *linestyle, const LineStyleModifier *m, int flag)
int BKE_linestyle_geometry_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *modifier)
#define NODE_CLASS_TEXTURE
Definition BKE_node.hh:443
#define SH_NODE_TEX_IMAGE
#define SH_NODE_UVALONGSTROKE
#define SH_NODE_OUTPUT_LINESTYLE
void BKE_ntree_update_after_single_tree_change(Main &bmain, bNodeTree &modified_tree, const NodeTreeUpdateExtraParams &params={})
void BKE_texture_mtex_foreach_id(struct LibraryForeachIDData *data, struct MTex *mtex)
Definition texture.cc:221
#define BLI_assert(a)
Definition BLI_assert.h:46
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:586
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:534
#define LISTBASE_FOREACH(type, var, list)
BLI_INLINE void BLI_listbase_clear(ListBase *lb)
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:270
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:111
void void void bool BLI_listbase_link_move(ListBase *listbase, void *vlink, int step) ATTR_NONNULL()
Definition listbase.cc:436
#define DEG2RADF(_deg)
char * STRNCPY(char(&dst)[N], const char *src)
Definition BLI_string.h:688
size_t BLI_str_escape(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
void BLI_uniquename(const struct ListBase *list, void *vlink, const char *defname, char delim, int name_offset, size_t name_maxncpy) ATTR_NONNULL(1
#define UNLIKELY(x)
#define MEMCMP_STRUCT_AFTER_IS_ZERO(struct_var, member)
#define MEMCPY_STRUCT_AFTER(struct_dst, struct_src, member)
#define BLO_write_id_struct(writer, struct_name, id_address, id)
#define BLO_write_struct(writer, struct_name, data_ptr)
void BLO_read_struct_list_with_type_size(BlendDataReader *reader, size_t base_size, ListBase *list, blender::FunctionRef< size_t(const void *data)> type_size_fn)
Definition readfile.cc:5647
#define BLO_read_struct(reader, struct_name, ptr_p)
void BLO_write_struct_by_id(BlendWriter *writer, int struct_id, const void *data_ptr)
#define BLO_write_struct_at_address(writer, struct_name, address, data_ptr)
#define BLT_I18NCONTEXT_ID_FREESTYLELINESTYLE
#define DATA_(msgid)
@ INDEX_ID_LS
Definition DNA_ID.h:1222
@ ID_LS
#define DNA_struct_default_get(struct_name)
@ LS_MODIFIER_BLUEPRINT_CIRCLES
@ LS_MODIFIER_SPATIAL_NOISE_PURERANDOM
@ LS_MODIFIER_SPATIAL_NOISE_SMOOTH
@ LS_MODIFIER_SAMPLING
@ LS_MODIFIER_BEZIER_CURVE
@ LS_MODIFIER_NOISE
@ LS_MODIFIER_BACKBONE_STRETCHER
@ LS_MODIFIER_SPATIAL_NOISE
@ LS_MODIFIER_PERLIN_NOISE_2D
@ LS_MODIFIER_POLYGONIZATION
@ LS_MODIFIER_GUIDING_LINES
@ LS_MODIFIER_SIMPLIFICATION
@ LS_MODIFIER_TANGENT
@ LS_MODIFIER_CREASE_ANGLE
@ LS_MODIFIER_NUM
@ LS_MODIFIER_2D_TRANSFORM
@ LS_MODIFIER_DISTANCE_FROM_OBJECT
@ LS_MODIFIER_BLUEPRINT
@ LS_MODIFIER_CALLIGRAPHY
@ LS_MODIFIER_CURVATURE_3D
@ LS_MODIFIER_SINUS_DISPLACEMENT
@ LS_MODIFIER_ALONG_STROKE
@ LS_MODIFIER_MATERIAL
@ LS_MODIFIER_DISTANCE_FROM_CAMERA
@ LS_MODIFIER_PERLIN_NOISE_1D
@ LS_MODIFIER_2D_OFFSET
@ LS_MODIFIER_TIP_REMOVER
@ LS_MODIFIER_2D_TRANSFORM_PIVOT_CENTER
@ LS_THICKNESS_ASYMMETRIC
@ LS_MODIFIER_MATERIAL_LINE
@ LS_MODIFIER_MATERIAL_LINE_A
@ LS_MODIFIER_EXPANDED
@ LS_MODIFIER_ENABLED
@ LS_VALUE_BLEND
@ MA_RAMP_BLEND
Object is a sort of wrapper for general info.
Read Guarded memory(de)allocation.
#define C
Definition RandGen.cpp:29
#define MAX_MTEX
Definition Stroke.h:31
BMesh const char void * data
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
Definition btDbvt.cpp:52
#define offsetof(t, d)
#define printf(...)
#define FILTER_ID_OB
#define MEM_SAFE_FREE(v)
#define FILTER_ID_TE
#define FILTER_ID_LS
static void direct_link_linestyle_alpha_modifier(BlendDataReader *reader, LineStyleModifier *modifier)
Definition linestyle.cc:509
static void linestyle_free_data(ID *id)
Definition linestyle.cc:112
static void linestyle_init_data(ID *id)
Definition linestyle.cc:50
static void direct_link_linestyle_color_modifier(BlendDataReader *reader, LineStyleModifier *modifier)
Definition linestyle.cc:460
static void write_linestyle_geometry_modifiers(BlendWriter *writer, ListBase *modifiers)
Definition linestyle.cc:381
static size_t color_modifier_struct_size(int type)
Definition linestyle.cc:751
static size_t thickness_modifier_struct_size(int type)
static void write_linestyle_alpha_modifiers(BlendWriter *writer, ListBase *modifiers)
Definition linestyle.cc:248
static void direct_link_linestyle_thickness_modifier(BlendDataReader *reader, LineStyleModifier *modifier)
Definition linestyle.cc:566
static LineStyleModifier * alloc_geometry_modifier(const char *name, int type)
static void write_linestyle_thickness_modifiers(BlendWriter *writer, ListBase *modifiers)
Definition linestyle.cc:314
int sdna_struct_id_get()
static void write_linestyle_color_modifiers(BlendWriter *writer, ListBase *modifiers)
Definition linestyle.cc:181
static size_t geometry_modifier_struct_size(int type)
static void linestyle_blend_read_data(BlendDataReader *reader, ID *id)
Definition linestyle.cc:640
static LineStyleModifier * new_modifier(const char *name, int type, size_t size)
Definition linestyle.cc:728
static void linestyle_blend_write(BlendWriter *writer, ID *id, const void *id_address)
Definition linestyle.cc:435
static size_t alpha_modifier_struct_size(int type)
Definition linestyle.cc:969
static LineStyleModifier * alloc_alpha_modifier(const char *name, int type)
Definition linestyle.cc:993
static void linestyle_modifiers_read(BlendDataReader *reader, ListBase *modifiers, size_t(*struct_size)(int))
Definition linestyle.cc:630
static LineStyleModifier * alloc_color_modifier(const char *name, int type)
Definition linestyle.cc:775
static void linestyle_foreach_id(ID *id, LibraryForeachIDData *data)
Definition linestyle.cc:142
static const char * modifier_name[LS_MODIFIER_NUM]
Definition linestyle.cc:696
static LineStyleModifier * alloc_thickness_modifier(const char *name, int type)
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
static void add_to_modifier_list(ListBase *lb, LineStyleModifier *m)
Definition linestyle.cc:744
static void direct_link_linestyle_geometry_modifier(BlendDataReader *, LineStyleModifier *)
Definition linestyle.cc:620
void * MEM_callocN(size_t len, const char *str)
Definition mallocn.cc:118
void * MEM_dupallocN(const void *vmemh)
Definition mallocn.cc:143
void MEM_freeN(void *vmemh)
Definition mallocn.cc:113
bNodeTree * node_tree_add_tree_embedded(Main *bmain, ID *owner_id, StringRefNull name, StringRefNull idname)
Definition node.cc:4375
void node_tree_blend_write(BlendWriter *writer, bNodeTree *ntree)
Definition node.cc:1464
bNode * node_add_static_node(const bContext *C, bNodeTree &ntree, int type)
Definition node.cc:3804
bNodeLink & node_add_link(bNodeTree &ntree, bNode &fromnode, bNodeSocket &fromsock, bNode &tonode, bNodeSocket &tosock)
Definition node.cc:4087
void node_set_active(bNodeTree &ntree, bNode &node)
Definition node.cc:4996
void node_tree_free_embedded_tree(bNodeTree *ntree)
Definition node.cc:4724
int sdna_struct_id_get()
struct FreestyleLineStyle * linestyle
struct bNodeTree * nodetree
struct MTex * mtex[18]
Definition DNA_ID.h:404
void * data
void * first
struct FreestyleConfig freestyle_config
ListBase nodes
float location[2]
int16_t custom1
ListBase inputs
ListBase outputs
int16_t custom2
i
Definition text_draw.cc:230
#define N_(msgid)