Blender V5.3
MOD_grease_pencil_smooth.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2005 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BLI_index_mask.hh"
10
11#include "BLT_translation.hh"
12
13#include "BLO_read_write.hh"
14
15#include "DNA_modifier_types.h"
16#include "DNA_screen_types.h"
17
18#include "RNA_access.hh"
19
20#include "BKE_curves.hh"
21#include "BKE_geometry_set.hh"
22#include "BKE_grease_pencil.hh"
23#include "BKE_modifier.hh"
24
26#include "UI_resources.hh"
27
28#include "GEO_smooth_curves.hh"
29
31#include "MOD_ui_common.hh"
32
33#include "RNA_prototypes.hh"
34
35namespace blender {
36
43
44static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
45{
47 reinterpret_cast<const GreasePencilSmoothModifierData *>(md);
49 target);
50
51 BKE_modifier_copydata_generic(md, target, flag);
53}
54
61
62static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
63{
65
67}
68
69static void blend_write(BlendWriter *writer, const ID * /*id_owner*/, const ModifierData *md)
70{
72 reinterpret_cast<const GreasePencilSmoothModifierData *>(md);
73
74 writer->write_struct(mmd);
76}
77
83
84static void deform_drawing(const ModifierData &md,
85 const Object &ob,
87{
88 const auto &mmd = reinterpret_cast<const GreasePencilSmoothModifierData &>(md);
89
90 const int iterations = mmd.step;
91 const float influence = mmd.factor;
92 const bool keep_shape = (mmd.flag & MOD_GREASE_PENCIL_SMOOTH_KEEP_SHAPE);
93 const bool smooth_ends = (mmd.flag & MOD_GREASE_PENCIL_SMOOTH_SMOOTH_ENDS);
94
95 const bool smooth_position = (mmd.flag & MOD_GREASE_PENCIL_SMOOTH_MOD_LOCATION);
96 const bool smooth_radius = (mmd.flag & MOD_GREASE_PENCIL_SMOOTH_MOD_THICKNESS);
97 const bool smooth_opacity = (mmd.flag & MOD_GREASE_PENCIL_SMOOTH_MOD_STRENGTH);
98 const bool smooth_uv = (mmd.flag & MOD_GREASE_PENCIL_SMOOTH_MOD_UV);
99
100 if (iterations <= 0 || influence <= 0.0f) {
101 return;
102 }
103
104 if (!(smooth_position || smooth_radius || smooth_opacity || smooth_uv)) {
105 return;
106 }
107
110 if (curves.is_empty()) {
111 return;
112 }
113
114 IndexMaskMemory memory;
116 &ob, curves, mmd.influence, memory);
117
118 if (strokes.is_empty()) {
119 return;
120 }
121
122 bke::MutableAttributeAccessor attributes = curves.attributes_for_write();
123 const OffsetIndices points_by_curve = curves.points_by_curve();
124 const VArray<bool> cyclic = curves.cyclic();
125 const VArray<bool> point_selection = VArray<bool>::from_single(true, curves.points_num());
126
127 VArray<float> influences;
128 const bool use_influence_vertex_group = mmd.influence.vertex_group_name[0] != '\0';
129 if (use_influence_vertex_group) {
131 curves, mmd.influence);
132 Array<float> vgroup_weights_factored(vgroup_weights.size());
134 vgroup_weights_factored.index_range(), 4096, [&](const IndexRange range) {
135 for (const int i : range) {
136 vgroup_weights_factored[i] = vgroup_weights[i] * influence;
137 }
138 });
139 influences = VArray<float>::from_container(vgroup_weights_factored);
140 }
141 else {
142 influences = VArray<float>::from_single(influence, curves.points_num());
143 }
144
145 if (smooth_position) {
146 bke::GSpanAttributeWriter positions = attributes.lookup_for_write_span("position");
148 points_by_curve,
149 point_selection,
150 cyclic,
151 iterations,
152 influences,
153 smooth_ends,
154 keep_shape,
155 positions.span);
156 positions.finish();
157 drawing.tag_positions_changed();
158 }
159 if (smooth_opacity && drawing.opacities().is_span()) {
160 bke::GSpanAttributeWriter opacities = attributes.lookup_for_write_span("opacity");
162 points_by_curve,
163 point_selection,
164 cyclic,
165 iterations,
166 influences,
167 smooth_ends,
168 false,
169 opacities.span);
170 opacities.finish();
171 }
172 if (smooth_radius && drawing.radii().is_span()) {
173 bke::GSpanAttributeWriter radii = attributes.lookup_for_write_span("radius");
175 points_by_curve,
176 point_selection,
177 cyclic,
178 iterations,
179 influences,
180 smooth_ends,
181 false,
182 radii.span);
183 radii.finish();
184 }
185 if (smooth_uv) {
186 bke::SpanAttributeWriter<float> rotation = attributes.lookup_for_write_span<float>("rotation");
187 if (rotation) {
189 points_by_curve,
190 point_selection,
191 cyclic,
192 iterations,
193 influences,
194 smooth_ends,
195 false,
196 rotation.span);
197 }
198 rotation.finish();
199 }
200}
201
203 const ModifierEvalContext *ctx,
204 bke::GeometrySet *geometry_set)
205{
207
208 if (!geometry_set->has_grease_pencil()) {
209 return;
210 }
212 const int current_frame = grease_pencil.runtime->eval_frame;
213
214 IndexMaskMemory mask_memory;
216 grease_pencil, mmd->influence, mask_memory);
219
221 deform_drawing(*md, *ctx->object, *drawing);
222 });
223}
224
225static void panel_draw(const bContext *C, Panel *panel)
226{
227 ui::Layout &layout = *panel->layout;
228
230
231 ui::Layout &row = layout.row(true);
232 row.prop(ptr, "use_edit_position", ui::ITEM_R_TOGGLE, IFACE_("Position"), ICON_NONE);
233 row.prop(ptr,
234 "use_edit_strength",
237 ICON_NONE);
238 row.prop(ptr, "use_edit_thickness", ui::ITEM_R_TOGGLE, IFACE_("Thickness"), ICON_NONE);
239
240 row.prop(ptr, "use_edit_uv", ui::ITEM_R_TOGGLE, IFACE_("UV"), ICON_NONE);
241
242 layout.use_property_split_set(true);
243
244 layout.prop(ptr, "factor", UI_ITEM_NONE, std::nullopt, ICON_NONE);
245 layout.prop(ptr, "step", UI_ITEM_NONE, IFACE_("Repeat"), ICON_NONE);
246
247 ui::Layout &col = layout.column(false);
248 col.active_set(RNA_boolean_get(ptr, "use_edit_position"));
249 col.prop(ptr, "use_keep_shape", UI_ITEM_NONE, std::nullopt, ICON_NONE);
250 col.prop(ptr, "use_smooth_ends", UI_ITEM_NONE, std::nullopt, ICON_NONE);
251
252 if (ui::Layout *influence_panel = layout.panel_prop(
253 C, ptr, "open_influence_panel", IFACE_("Influence")))
254 {
258 }
259
260 modifier_error_message_draw(layout, ptr);
261}
262
267
269 /*idname*/ "GreasePencilSmoothModifier",
270 /*name*/ N_("Smooth"),
271 /*struct_name*/ "GreasePencilSmoothModifierData",
272 /*struct_size*/ sizeof(GreasePencilSmoothModifierData),
273 /*srna*/ &RNA_GreasePencilSmoothModifier,
275 /*flags*/
278 /*icon*/ ICON_SMOOTHCURVE,
279
280 /*copy_data*/ copy_data,
281
282 /*deform_verts*/ nullptr,
283 /*deform_matrices*/ nullptr,
284 /*deform_verts_EM*/ nullptr,
285 /*deform_matrices_EM*/ nullptr,
286 /*modify_mesh*/ nullptr,
287 /*modify_geometry_set*/ modify_geometry_set,
288
289 /*init_data*/ init_data,
290 /*required_data_mask*/ nullptr,
291 /*free_data*/ free_data,
292 /*is_disabled*/ nullptr,
293 /*update_depsgraph*/ nullptr,
294 /*depends_on_time*/ nullptr,
295 /*depends_on_normals*/ nullptr,
296 /*foreach_ID_link*/ foreach_ID_link,
297 /*foreach_tex_link*/ nullptr,
298 /*free_runtime_data*/ nullptr,
299 /*panel_register*/ panel_register,
300 /*blend_write*/ blend_write,
301 /*blend_read*/ blend_read,
302};
303
304} // namespace blender
Low-level operations for curves.
Low-level operations for grease pencil.
#define BLT_I18NCONTEXT_ID_GPENCIL
#define CTX_IFACE_(context, msgid)
#define IFACE_(msgid)
#define C
Definition RandGen.cpp:29
#define UI_ITEM_NONE
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
IndexRange index_range() const
Definition BLI_array.hh:371
static VArray from_single(T value, const int64_t size)
static VArray from_container(ContainerT container)
bke::CurvesGeometry & strokes_for_write()
void smooth_curve_attribute(const IndexMask &curves_to_smooth, const OffsetIndices< int > points_by_curve, const VArray< bool > &point_selection, const VArray< bool > &cyclic, int iterations, float influence, bool smooth_ends, bool keep_shape, GMutableSpan attribute_data)
void read_influence_data(BlendDataReader *reader, GreasePencilModifierInfluenceData *influence_data)
void draw_material_filter_settings(const bContext *, ui::Layout &layout, PointerRNA *ptr)
void init_influence_data(GreasePencilModifierInfluenceData *influence_data, const bool has_custom_curve)
void write_influence_data(BlendWriter *writer, const GreasePencilModifierInfluenceData *influence_data)
void draw_layer_filter_settings(const bContext *, ui::Layout &layout, PointerRNA *ptr)
IndexMask get_filtered_layer_mask(const GreasePencil &grease_pencil, const GreasePencilModifierInfluenceData &influence_data, IndexMaskMemory &memory)
VArray< float > get_influence_vertex_weights(const bke::CurvesGeometry &curves, const GreasePencilModifierInfluenceData &influence_data)
Vector< bke::greasepencil::Drawing * > get_drawings_for_write(GreasePencil &grease_pencil, const IndexMask &layer_mask, const int frame)
IndexMask get_filtered_stroke_mask(const Object *ob, const bke::CurvesGeometry &curves, const GreasePencilModifierInfluenceData &influence_data, IndexMaskMemory &memory)
void draw_vertex_group_settings(const bContext *, ui::Layout &layout, PointerRNA *ptr)
void free_influence_data(GreasePencilModifierInfluenceData *influence_data)
void foreach_influence_ID_link(GreasePencilModifierInfluenceData *influence_data, Object *ob, IDWalkFunc walk, void *user_data)
void copy_influence_data(const GreasePencilModifierInfluenceData *influence_data_src, GreasePencilModifierInfluenceData *influence_data_dst, const int)
void ensure_no_bezier_curves(Drawing &drawing)
void parallel_for_each(Range &&range, const Function &function)
Definition BLI_task.hh:31
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Definition BLI_task.hh:69
BMesh Iterators.
static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
static void blend_write(BlendWriter *writer, const ID *, const ModifierData *md)
Definition MOD_bevel.cc:454
PointerRNA * modifier_panel_get_property_pointers(Panel *panel, PointerRNA *r_ob_ptr)
@ eModifierType_GreasePencilSmooth
static void init_data(ModifierData *md)
void(*)(void *user_data, Object *ob, ID **idpoin, LibraryForeachIDCallbackFlag cb_flag) IDWalkFunc
static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
static void modify_geometry_set(ModifierData *md, const ModifierEvalContext *ctx, bke::GeometrySet *geometry_set)
static void deform_drawing(const ModifierData &md, const Object &ob, bke::greasepencil::Drawing &drawing)
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
@ MOD_GREASE_PENCIL_SMOOTH_SMOOTH_ENDS
@ MOD_GREASE_PENCIL_SMOOTH_MOD_UV
@ MOD_GREASE_PENCIL_SMOOTH_MOD_STRENGTH
@ MOD_GREASE_PENCIL_SMOOTH_MOD_LOCATION
@ MOD_GREASE_PENCIL_SMOOTH_KEEP_SHAPE
@ MOD_GREASE_PENCIL_SMOOTH_MOD_THICKNESS
ModifierTypeInfo modifierType_GreasePencilSmooth
static void free_data(ModifierData *md)
static void panel_register(ARegionType *region_type)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
@ eModifierTypeFlag_SupportsMapping
@ eModifierTypeFlag_AcceptsGreasePencil
@ eModifierTypeFlag_EnableInEditmode
@ eModifierTypeFlag_SupportsEditmode
static void blend_read(BlendDataReader *, ModifierData *md)
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
static void panel_draw(const bContext *, Panel *panel)
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
GreasePencilModifierInfluenceData influence
ui::Layout * layout
GreasePencil * get_grease_pencil_for_write()
void use_property_split_set(bool is_sep)
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)
void active_set(bool active)
Layout & column(bool align)
PanelLayout panel_prop(const bContext *C, PointerRNA *open_prop_owner, StringRefNull open_prop_name)
Layout & row(bool align)
#define N_(msgid)