Blender V5.3
MOD_grease_pencil_shrinkwrap.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BKE_attribute.hh"
10#include "BKE_material.hh"
11
12#include "DNA_meshdata_types.h"
13#include "DNA_modifier_types.h"
14#include "DNA_scene_types.h"
15
16#include "BKE_curves.hh"
17#include "BKE_deform.hh"
18#include "BKE_geometry_set.hh"
19#include "BKE_grease_pencil.hh"
20#include "BKE_instances.hh"
21#include "BKE_lib_query.hh"
22#include "BKE_modifier.hh"
23#include "BKE_screen.hh"
24#include "BKE_shrinkwrap.hh"
25
26#include "BLO_read_write.hh"
27
29
30#include "GEO_smooth_curves.hh"
31
33#include "UI_resources.hh"
34
35#include "BLT_translation.hh"
36
37#include "WM_api.hh"
38#include "WM_types.hh"
39
40#include "RNA_access.hh"
41#include "RNA_prototypes.hh"
42
44#include "MOD_ui_common.hh"
45
46namespace blender {
47
48static void init_data(ModifierData *md)
49{
50 auto *smd = reinterpret_cast<GreasePencilShrinkwrapModifierData *>(md);
52 modifier::greasepencil::init_influence_data(&smd->influence, false);
53}
54
55static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
56{
57 const auto *smd = reinterpret_cast<const GreasePencilShrinkwrapModifierData *>(md);
58 auto *tsmd = reinterpret_cast<GreasePencilShrinkwrapModifierData *>(target);
59
61
62 BKE_modifier_copydata_generic(md, target, flag);
63 modifier::greasepencil::copy_influence_data(&smd->influence, &tsmd->influence, flag);
64}
65
66static void free_data(ModifierData *md)
67{
68 auto *smd = reinterpret_cast<GreasePencilShrinkwrapModifierData *>(md);
70
71 if (smd->cache_data) {
72 BKE_shrinkwrap_free_tree(smd->cache_data);
73 MEM_delete(smd->cache_data);
74 }
75}
76
77static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
78{
79 auto *smd = reinterpret_cast<GreasePencilShrinkwrapModifierData *>(md);
80 modifier::greasepencil::foreach_influence_ID_link(&smd->influence, ob, walk, user_data);
81 walk(user_data, ob, reinterpret_cast<ID **>(&smd->target), IDWALK_CB_NOP);
82 walk(user_data, ob, reinterpret_cast<ID **>(&smd->aux_target), IDWALK_CB_NOP);
83}
84
85static bool is_disabled(const Scene * /*scene*/, ModifierData *md, bool /*use_render_params*/)
86{
87 auto *smd = reinterpret_cast<GreasePencilShrinkwrapModifierData *>(md);
88
89 /* The object type check is only needed here in case we have a placeholder
90 * object assigned (because the library containing the mesh is missing).
91 *
92 * In other cases it should be impossible to have a type mismatch.
93 */
94 if (smd->target == nullptr || smd->target->type != OB_MESH) {
95 return true;
96 }
97 if (smd->aux_target != nullptr && smd->aux_target->type != OB_MESH) {
98 return true;
99 }
100 return false;
101}
102
104{
105 auto *smd = reinterpret_cast<GreasePencilShrinkwrapModifierData *>(md);
106
107 if (smd->target != nullptr) {
109 ctx->node, smd->target, DEG_OB_COMP_TRANSFORM, "Grease Pencil Shrinkwrap Modifier");
111 ctx->node, smd->target, DEG_OB_COMP_GEOMETRY, "Grease Pencil Shrinkwrap Modifier");
112 if (smd->shrink_type == MOD_SHRINKWRAP_TARGET_PROJECT) {
114 }
115 }
116 if (smd->aux_target != nullptr) {
118 ctx->node, smd->aux_target, DEG_OB_COMP_TRANSFORM, "Grease Pencil Shrinkwrap Modifier");
120 ctx->node, smd->aux_target, DEG_OB_COMP_GEOMETRY, "Grease Pencil Shrinkwrap Modifier");
121 if (smd->shrink_type == MOD_SHRINKWRAP_TARGET_PROJECT) {
123 ctx->node, &smd->aux_target->id, DAG_EVAL_NEED_SHRINKWRAP_BOUNDARY);
124 }
125 }
126 DEG_add_depends_on_transform_relation(ctx->node, "Grease Pencil Shrinkwrap Modifier");
127}
128
130 const ModifierEvalContext &ctx,
132{
135 const OffsetIndices<int> points_by_curve = curves.points_by_curve();
136 const Span<MDeformVert> dverts = curves.deform_verts();
137 const MutableSpan<float3> positions = curves.positions_for_write();
138 const int defgrp_idx = BKE_object_defgroup_name_index(ctx.object,
140
141 /* Selected source curves. */
142 IndexMaskMemory curve_mask_memory;
144 ctx.object, drawing.strokes(), smd.influence, curve_mask_memory);
145
146 ShrinkwrapParams params;
147 params.target = smd.target;
148 params.aux_target = smd.aux_target;
150 params.keep_distance = smd.keep_dist;
151 params.shrink_type = smd.shrink_type;
152 params.shrink_options = smd.shrink_opts;
153 params.shrink_mode = smd.shrink_mode;
154 params.projection_limit = smd.proj_limit;
155 params.projection_axis = smd.proj_axis;
156 params.subsurf_levels = smd.subsurf_levels;
157
158 curves_mask.foreach_index([&](const int curve_i) {
159 const IndexRange points = points_by_curve[curve_i];
160 const Span<MDeformVert> curve_dverts = dverts.is_empty() ? dverts : dverts.slice(points);
161 const MutableSpan<float3> curve_positions = positions.slice(points);
162
164 params, *ctx.object, *smd.cache_data, curve_dverts, defgrp_idx, curve_positions);
165 });
166
167 /* Optional smoothing after shrinkwrap. */
168 const VArray<bool> point_selection = VArray<bool>::from_single(true, curves.points_num());
169 const bool smooth_ends = false;
170 const bool keep_shape = true;
172 points_by_curve,
173 point_selection,
174 curves.cyclic(),
175 smd.smooth_step,
176 smd.smooth_factor,
177 smooth_ends,
178 keep_shape,
179 positions);
180
181 drawing.tag_positions_changed();
182}
183
185 const ModifierEvalContext &ctx)
186{
187 if (smd.cache_data) {
189 MEM_delete(smd.cache_data);
190 smd.cache_data = nullptr;
191 }
192 Object *target_ob = DEG_get_evaluated(ctx.depsgraph, smd.target);
194
195 smd.cache_data = MEM_new<ShrinkwrapTreeData>(__func__);
196 const bool tree_ok = BKE_shrinkwrap_init_tree(
197 smd.cache_data, target_mesh, smd.shrink_type, smd.shrink_mode, false);
198 if (!tree_ok) {
199 MEM_delete(smd.cache_data);
200 smd.cache_data = nullptr;
201 }
202}
203
205 const ModifierEvalContext *ctx,
206 bke::GeometrySet *geometry_set)
207{
211
212 auto &smd = *reinterpret_cast<GreasePencilShrinkwrapModifierData *>(md);
213 BLI_assert(smd.target != nullptr);
214 if (smd.target == ctx->object || smd.aux_target == ctx->object) {
215 return;
216 }
217 if (!geometry_set->has_grease_pencil()) {
218 return;
219 }
221 const int frame = grease_pencil.runtime->eval_frame;
222
224 if (!smd.cache_data) {
225 return;
226 }
227
228 IndexMaskMemory mask_memory;
230 grease_pencil, smd.influence, mask_memory);
231
233 grease_pencil, layer_mask, frame);
235 [&](Drawing *drawing) { modify_drawing(smd, *ctx, *drawing); });
236}
237
238static void panel_draw(const bContext *C, Panel *panel)
239{
240 static const ui::eUI_Item_Flag toggles_flag = ui::ITEM_R_TOGGLE |
242
243 ui::Layout &layout = *panel->layout;
244
245 PointerRNA ob_ptr;
247 int wrap_method = RNA_enum_get(ptr, "wrap_method");
248
249 layout.use_property_split_set(true);
250
251 layout.prop(ptr, "wrap_method", UI_ITEM_NONE, std::nullopt, ICON_NONE);
252
253 if (ELEM(wrap_method,
257 {
258 layout.prop(ptr, "wrap_mode", UI_ITEM_NONE, std::nullopt, ICON_NONE);
259 }
260
261 if (wrap_method == MOD_SHRINKWRAP_PROJECT) {
262 layout.prop(ptr, "project_limit", UI_ITEM_NONE, IFACE_("Limit"), ICON_NONE);
263 layout.prop(ptr, "subsurf_levels", UI_ITEM_NONE, std::nullopt, ICON_NONE);
264
265 ui::Layout *col = &layout.column(false);
266 ui::Layout &row = col->row(true, IFACE_("Axis"));
267 row.prop(ptr, "use_project_x", toggles_flag, std::nullopt, ICON_NONE);
268 row.prop(ptr, "use_project_y", toggles_flag, std::nullopt, ICON_NONE);
269 row.prop(ptr, "use_project_z", toggles_flag, std::nullopt, ICON_NONE);
270
271 col->prop(ptr, "use_negative_direction", UI_ITEM_NONE, std::nullopt, ICON_NONE);
272 col->prop(ptr, "use_positive_direction", UI_ITEM_NONE, std::nullopt, ICON_NONE);
273
274 layout.prop(ptr, "cull_face", ui::ITEM_R_EXPAND, std::nullopt, ICON_NONE);
275 col = &layout.column(false);
276 col->active_set(RNA_boolean_get(ptr, "use_negative_direction") &&
277 RNA_enum_get(ptr, "cull_face") != 0);
278 col->prop(ptr, "use_invert_cull", UI_ITEM_NONE, std::nullopt, ICON_NONE);
279 }
280
281 layout.prop(ptr, "target", UI_ITEM_NONE, std::nullopt, ICON_NONE);
282 if (wrap_method == MOD_SHRINKWRAP_PROJECT) {
283 layout.prop(ptr, "auxiliary_target", UI_ITEM_NONE, std::nullopt, ICON_NONE);
284 }
285 layout.prop(ptr, "offset", UI_ITEM_NONE, std::nullopt, ICON_NONE);
286
287 layout.use_property_split_set(true);
288
289 layout.prop(ptr, "smooth_factor", UI_ITEM_NONE, std::nullopt, ICON_NONE);
290 layout.prop(ptr, "smooth_step", UI_ITEM_NONE, IFACE_("Repeat"), ICON_NONE);
291
292 if (ui::Layout *influence_panel = layout.panel_prop(
293 C, ptr, "open_influence_panel", IFACE_("Influence")))
294 {
298 }
299
300 modifier_error_message_draw(layout, ptr);
301}
302
307
308static void blend_write(BlendWriter *writer, const ID * /*id_owner*/, const ModifierData *md)
309{
310 const auto *smd = reinterpret_cast<const GreasePencilShrinkwrapModifierData *>(md);
311
312 writer->write_struct(smd);
313 modifier::greasepencil::write_influence_data(writer, &smd->influence);
314}
315
316static void blend_read(BlendDataReader *reader, ModifierData *md)
317{
318 auto *smd = reinterpret_cast<GreasePencilShrinkwrapModifierData *>(md);
319
320 modifier::greasepencil::read_influence_data(reader, &smd->influence);
321}
322
324 /*idname*/ "GreasePencilShrinkwrap",
325 /*name*/ N_("Shrinkwrap"),
326 /*struct_name*/ "GreasePencilShrinkwrapModifierData",
327 /*struct_size*/ sizeof(GreasePencilShrinkwrapModifierData),
328 /*srna*/ &RNA_GreasePencilShrinkwrapModifier,
332 /*icon*/ ICON_MOD_SHRINKWRAP,
333
334 /*copy_data*/ copy_data,
335
336 /*deform_verts*/ nullptr,
337 /*deform_matrices*/ nullptr,
338 /*deform_verts_EM*/ nullptr,
339 /*deform_matrices_EM*/ nullptr,
340 /*modify_mesh*/ nullptr,
341 /*modify_geometry_set*/ modify_geometry_set,
342
343 /*init_data*/ init_data,
344 /*required_data_mask*/ nullptr,
345 /*free_data*/ free_data,
346 /*is_disabled*/ is_disabled,
347 /*update_depsgraph*/ update_depsgraph,
348 /*depends_on_time*/ nullptr,
349 /*depends_on_normals*/ nullptr,
350 /*foreach_ID_link*/ foreach_ID_link,
351 /*foreach_tex_link*/ nullptr,
352 /*free_runtime_data*/ nullptr,
353 /*panel_register*/ panel_register,
354 /*blend_write*/ blend_write,
355 /*blend_read*/ blend_read,
356};
357
358} // namespace blender
Low-level operations for curves.
support for deformation groups and hooks.
Low-level operations for grease pencil.
General operations, lookup, etc. for materials.
#define IFACE_(msgid)
#define C
Definition RandGen.cpp:29
#define UI_ITEM_NONE
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
#define ELEM(...)
constexpr MutableSpan slice(const int64_t start, const int64_t size) const
Definition BLI_span.hh:579
constexpr Span slice(int64_t start, int64_t size) const
Definition BLI_span.hh:141
constexpr bool is_empty() const
Definition BLI_span.hh:264
static VArray from_single(T value, const int64_t size)
bke::CurvesGeometry & strokes_for_write()
const bke::CurvesGeometry & strokes() const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
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)
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
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
void shrinkwrapParams_deform(const ShrinkwrapParams &params, Object &object, ShrinkwrapTreeData &tree, Span< MDeformVert > dvert, int defgrp_index, MutableSpan< float3 > positions)
int RNA_enum_get(PointerRNA *ptr, const char *name)
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)
void DEG_add_special_eval_flag(DepsNodeHandle *handle, ID *id, uint32_t flag)
@ eModifierType_GreasePencilShrinkwrap
static void init_data(ModifierData *md)
void(*)(void *user_data, Object *ob, ID **idpoin, LibraryForeachIDCallbackFlag cb_flag) IDWalkFunc
static void update_depsgraph(tGraphSliderOp *gso)
void BKE_shrinkwrap_free_tree(ShrinkwrapTreeData *data)
static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
@ GREASE_PENCIL_INFLUENCE_INVERT_VERTEX_GROUP
void DEG_add_object_relation(DepsNodeHandle *node_handle, Object *object, eDepsObjectComponentType component, const char *description)
void DEG_add_depends_on_transform_relation(DepsNodeHandle *node_handle, const char *description)
static void modify_geometry_set(ModifierData *md, const ModifierEvalContext *ctx, bke::GeometrySet *geometry_set)
Mesh * BKE_modifier_get_evaluated_mesh_from_evaluated_object(Object *ob_eval)
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
static void free_data(ModifierData *md)
static void panel_register(ARegionType *region_type)
int BKE_object_defgroup_name_index(const Object *ob, StringRef name)
Definition deform.cc:597
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
@ MOD_SHRINKWRAP_NEAREST_SURFACE
@ MOD_SHRINKWRAP_TARGET_PROJECT
@ eModifierTypeFlag_SupportsMapping
@ eModifierTypeFlag_AcceptsGreasePencil
@ eModifierTypeFlag_EnableInEditmode
@ eModifierTypeFlag_SupportsEditmode
@ DAG_EVAL_NEED_SHRINKWRAP_BOUNDARY
static void modify_drawing(const GreasePencilArrayModifierData &mmd, const ModifierEvalContext &ctx, bke::greasepencil::Drawing &drawing)
static void blend_read(BlendDataReader *, ModifierData *md)
ModifierTypeInfo modifierType_GreasePencilShrinkwrap
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
static void panel_draw(const bContext *, Panel *panel)
static void ensure_shrinkwrap_cache_data(GreasePencilShrinkwrapModifierData &smd, const ModifierEvalContext &ctx)
static bool is_disabled(const Scene *, ModifierData *md, bool)
bool BKE_shrinkwrap_init_tree(ShrinkwrapTreeData *data, Mesh *mesh, int shrinkType, int shrinkMode, bool force_normals)
Definition shrinkwrap.cc:87
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
GreasePencilModifierInfluenceFlag flag
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)