Blender V5.3
MOD_grease_pencil_armature.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
10#include "DNA_modifier_types.h"
11#include "DNA_scene_types.h"
12
13#include "BKE_armature.hh"
14#include "BKE_curves.hh"
15#include "BKE_geometry_set.hh"
16#include "BKE_grease_pencil.hh"
17#include "BKE_lib_query.hh"
18#include "BKE_material.hh"
19#include "BKE_modifier.hh"
20#include "BKE_screen.hh"
21
22#include "BLO_read_write.hh"
23
25
27#include "UI_resources.hh"
28
29#include "BLT_translation.hh"
30
31#include "WM_types.hh"
32
33#include "RNA_access.hh"
34#include "RNA_enum_types.hh"
35#include "RNA_prototypes.hh"
36
38#include "MOD_modifiertypes.hh"
39#include "MOD_ui_common.hh"
40
41namespace blender {
42
44
45static void init_data(ModifierData *md)
46{
47 auto *amd = reinterpret_cast<GreasePencilArmatureModifierData *>(md);
49 modifier::greasepencil::init_influence_data(&amd->influence, false);
50}
51
52static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
53{
54 const auto *amd = reinterpret_cast<const GreasePencilArmatureModifierData *>(md);
55 auto *tamd = reinterpret_cast<GreasePencilArmatureModifierData *>(target);
56
58
59 BKE_modifier_copydata_generic(md, target, flag);
60 modifier::greasepencil::copy_influence_data(&amd->influence, &tamd->influence, flag);
61}
62
63static void free_data(ModifierData *md)
64{
65 auto *amd = reinterpret_cast<GreasePencilArmatureModifierData *>(md);
67}
68
69static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
70{
71 auto *amd = reinterpret_cast<GreasePencilArmatureModifierData *>(md);
72 modifier::greasepencil::foreach_influence_ID_link(&amd->influence, ob, walk, user_data);
73 walk(user_data, ob, reinterpret_cast<ID **>(&amd->object), IDWALK_CB_NOP);
74}
75
76static bool is_disabled(const Scene * /*scene*/, ModifierData *md, bool /*use_render_params*/)
77{
78 auto *amd = reinterpret_cast<GreasePencilArmatureModifierData *>(md);
79
80 /* The object type check is only needed here in case we have a placeholder
81 * object assigned (because the library containing the armature is missing).
82 *
83 * In other cases it should be impossible to have a type mismatch. */
84 return !amd->object || amd->object->type != OB_ARMATURE;
85}
86
88{
89 auto *amd = reinterpret_cast<GreasePencilArmatureModifierData *>(md);
90 if (amd->object != nullptr) {
91 DEG_add_object_relation(ctx->node, amd->object, DEG_OB_COMP_EVAL_POSE, "Armature Modifier");
92 DEG_add_object_relation(ctx->node, amd->object, DEG_OB_COMP_TRANSFORM, "Armature Modifier");
93 }
94 DEG_add_object_relation(ctx->node, ctx->object, DEG_OB_COMP_TRANSFORM, "Armature Modifier");
95}
96
98{
99 if (attribute.sharing_info && attribute.varray.is_span()) {
100 const void *data = attribute.varray.get_internal_span().data();
101 attribute.sharing_info->add_user();
102 return {ImplicitSharingPtr(attribute.sharing_info), data};
103 }
104 auto *data = new ImplicitSharedValue<GArray<>>(attribute.varray.type(), attribute.varray.size());
105 attribute.varray.materialize(data->data.data());
106 return {ImplicitSharingPtr<>(data), data->data.data()};
107}
108
110 const ModifierEvalContext &ctx,
111 Drawing &drawing,
113{
114 const auto &amd = reinterpret_cast<GreasePencilArmatureModifierData &>(md);
115 /* The influence flag is where the "invert" flag is stored,
116 * but armature functions expect `deformflag` to have the flag set as well.
117 * Copy to `deformflag` here to keep old functions happy. */
118 const int deformflag = amd.deformflag |
119 (amd.influence.flag & GREASE_PENCIL_INFLUENCE_INVERT_VERTEX_GROUP ?
121 0);
122
123 if (drawing.strokes().deform_verts().is_empty()) {
124 return;
125 }
126
127 IndexMaskMemory mask_memory;
129 ctx.object, drawing.strokes(), amd.influence, mask_memory);
130
131 auto deform_curves = [&](MutableSpan<float3> positions,
132 std::optional<Span<float3>> old_positions,
133 std::optional<MutableSpan<float3x3>> deform_mats,
134 Span<MDeformVert> dverts,
135 const OffsetIndices<int> points_by_curve) {
136 /* Deform verts attribute can be empty after converting Bezier curves (#152102). */
137 if (dverts.is_empty()) {
138 return;
139 }
140 curves_mask.foreach_index(
141 [&](const int curve_i) {
142 const IndexRange points = points_by_curve[curve_i];
143 std::optional<Span<float3>> old_positions_for_curve;
144 if (old_positions) {
145 old_positions_for_curve = old_positions->slice(points);
146 }
147 std::optional<MutableSpan<float3x3>> deform_mats_for_curve;
148 if (deform_mats) {
149 deform_mats_for_curve = deform_mats->slice(points);
150 }
152 *ctx.object,
153 &drawing.strokes().vertex_group_names,
154 positions.slice(points),
155 old_positions_for_curve,
156 deform_mats_for_curve,
157 dverts.slice(points),
158 deformflag,
159 amd.influence.vertex_group_name);
160 },
162 };
163
164 /* Cached position data for supporting the multi-modifier feature. This data is only valid as
165 * long as topology does not change, don't use this after converting Bezier curves! */
166 const ImplicitSharingPtrAndData old_positions_data = save_shared_attribute(
167 drawing.strokes().attributes().lookup("position", bke::AttrType::Float3));
168 const Span<float3> old_positions = {static_cast<const float3 *>(old_positions_data.data),
169 drawing.strokes().points_num()};
170
171 const bool has_bezier_curves = drawing.strokes().has_curve_with_type(
173 if (has_bezier_curves) {
174 /* Update deformation data in edit hints related to original points.
175 * Do this before converting Bezier curves because that changes the topology.
176 * The multi-modifier feature is not supported in this case (no "old_positions" argument). */
177 if (edit_hints && edit_hints->positions()) {
178 const bke::CurvesGeometry &curves = drawing.strokes();
179 std::optional<MutableSpan<float3x3>> deform_mats =
180 edit_hints->deform_mats ?
181 edit_hints->deform_mats->as_mutable_span() :
182 edit_hints->deform_mats.emplace(curves.points_num(), float3x3::identity());
183 deform_curves(*edit_hints->positions_for_write(),
184 std::nullopt,
185 deform_mats,
186 curves.deform_verts(),
187 curves.points_by_curve());
188 }
189
190 /* Convert Bezier curves since these are not supported in armature deformation. */
192
193 /* Deform curve data without changes to edit hints. */
194 {
196 deform_curves(curves.positions_for_write(),
197 std::nullopt,
198 std::nullopt,
199 curves.deform_verts(),
200 curves.points_by_curve());
201 }
202 }
203 else {
204 /* Deform curve data and edit hints at the same time. */
206 std::optional<MutableSpan<float3x3>> deform_mats;
207 if (edit_hints) {
208 deform_mats = edit_hints->deform_mats ?
209 edit_hints->deform_mats->as_mutable_span() :
210 edit_hints->deform_mats.emplace(curves.points_num(), float3x3::identity());
211 }
212 deform_curves(curves.positions_for_write(),
213 old_positions,
214 deform_mats,
215 curves.deform_verts(),
216 curves.points_by_curve());
217 /* Copy deformed positions to edit hints if necessary. */
218 if (edit_hints && edit_hints->positions() &&
219 edit_hints->positions()->data() != curves.positions().data())
220 {
221 edit_hints->positions_for_write()->copy_from(curves.positions());
222 }
223 }
224
225 drawing.tag_positions_changed();
226}
227
229 const ModifierEvalContext *ctx,
230 bke::GeometrySet *geometry_set)
231{
232 using namespace modifier::greasepencil;
233
234 const auto *amd = reinterpret_cast<GreasePencilArmatureModifierData *>(md);
235
236 if (!geometry_set->has_grease_pencil()) {
237 return;
238 }
240
242 const int frame = grease_pencil.runtime->eval_frame;
243
245 if (geometry_set->has_component<bke::GeometryComponentEditData>()) {
246 bke::GeometryComponentEditData &edit_component =
248 if (auto &hints = edit_component.grease_pencil_edit_hints_) {
249 if (!hints->drawing_hints) {
250 hints->drawing_hints.emplace(hints->grease_pencil_id_orig.layers().size());
251 }
252 edit_hints = *hints->drawing_hints;
253 }
254 }
255
256 IndexMaskMemory mask_memory;
257 const IndexMask layer_mask = get_filtered_layer_mask(grease_pencil, amd->influence, mask_memory);
258 const Vector<LayerDrawingInfo> drawings = get_drawing_infos_by_layer(
259 grease_pencil, layer_mask, frame);
260 threading::parallel_for_each(drawings, [&](const LayerDrawingInfo &info) {
261 if (edit_hints.is_empty()) {
262 modify_curves(*md, *ctx, *info.drawing, nullptr);
263 }
264 else {
265 modify_curves(*md, *ctx, *info.drawing, &edit_hints[info.layer_index]);
266 }
267 });
268}
269
270static void panel_draw(const bContext *C, Panel *panel)
271{
272 ui::Layout &layout = *panel->layout;
273
274 PointerRNA ob_ptr;
276
277 layout.use_property_split_set(true);
278
279 layout.prop(ptr, "object", UI_ITEM_NONE, std::nullopt, ICON_NONE);
281
282 ui::Layout &col = layout.column(true, IFACE_("Bind To"));
283 col.prop(ptr, "use_vertex_groups", UI_ITEM_NONE, IFACE_("Vertex Groups"), ICON_NONE);
284 col.prop(ptr, "use_bone_envelopes", UI_ITEM_NONE, IFACE_("Bone Envelopes"), ICON_NONE);
285
286 modifier_error_message_draw(layout, ptr);
287}
288
293
294static void blend_write(BlendWriter *writer, const ID * /*id_owner*/, const ModifierData *md)
295{
296 const auto *amd = reinterpret_cast<const GreasePencilArmatureModifierData *>(md);
297
298 writer->write_struct(amd);
299 modifier::greasepencil::write_influence_data(writer, &amd->influence);
300}
301
302static void blend_read(BlendDataReader *reader, ModifierData *md)
303{
304 auto *amd = reinterpret_cast<GreasePencilArmatureModifierData *>(md);
305
306 modifier::greasepencil::read_influence_data(reader, &amd->influence);
307}
308
310 /*idname*/ "GreasePencilArmature",
311 /*name*/ N_("Armature"),
312 /*struct_name*/ "GreasePencilArmatureModifierData",
313 /*struct_size*/ sizeof(GreasePencilArmatureModifierData),
314 /*srna*/ &RNA_GreasePencilArmatureModifier,
318 /*icon*/ ICON_MOD_ARMATURE,
319
320 /*copy_data*/ copy_data,
321
322 /*deform_verts*/ nullptr,
323 /*deform_matrices*/ nullptr,
324 /*deform_verts_EM*/ nullptr,
325 /*deform_matrices_EM*/ nullptr,
326 /*modify_mesh*/ nullptr,
327 /*modify_geometry_set*/ modify_geometry_set,
328
329 /*init_data*/ init_data,
330 /*required_data_mask*/ nullptr,
331 /*free_data*/ free_data,
332 /*is_disabled*/ is_disabled,
333 /*update_depsgraph*/ update_depsgraph,
334 /*depends_on_time*/ nullptr,
335 /*depends_on_normals*/ nullptr,
336 /*foreach_ID_link*/ foreach_ID_link,
337 /*foreach_tex_link*/ nullptr,
338 /*free_runtime_data*/ nullptr,
339 /*panel_register*/ panel_register,
340 /*blend_write*/ blend_write,
341 /*blend_read*/ blend_read,
342};
343
344} // namespace blender
Low-level operations for curves.
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)
constexpr MutableSpan slice(const int64_t start, const int64_t size) const
Definition BLI_span.hh:579
constexpr bool is_empty() const
Definition BLI_span.hh:515
GAttributeReader lookup(const StringRef name) const
AttributeAccessor attributes() const
Span< MDeformVert > deform_verts() const
bool has_curve_with_type(CurveType type) const
std::unique_ptr< GreasePencilEditHints > grease_pencil_edit_hints_
static void remember_deformed_positions_if_necessary(GeometrySet &geometry)
std::optional< MutableSpan< float3 > > positions_for_write()
std::optional< Span< float3 > > positions() const
std::optional< Array< float3x3 > > deform_mats
bke::CurvesGeometry & strokes_for_write()
const bke::CurvesGeometry & strokes() const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
#define attribute(slot)
constexpr ParallelGrainSize grain_size(int grain_size)
void read_influence_data(BlendDataReader *reader, GreasePencilModifierInfluenceData *influence_data)
void init_influence_data(GreasePencilModifierInfluenceData *influence_data, const bool has_custom_curve)
void write_influence_data(BlendWriter *writer, const GreasePencilModifierInfluenceData *influence_data)
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.
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)
static void modify_curves(ModifierData &md, const ModifierEvalContext &ctx, Drawing &drawing, bke::GreasePencilDrawingEditHints *edit_hints)
@ eModifierType_GreasePencilArmature
static void init_data(ModifierData *md)
void(*)(void *user_data, Object *ob, ID **idpoin, LibraryForeachIDCallbackFlag cb_flag) IDWalkFunc
static void update_depsgraph(tGraphSliderOp *gso)
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)
static void modify_geometry_set(ModifierData *md, const ModifierEvalContext *ctx, bke::GeometrySet *geometry_set)
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
ModifierTypeInfo modifierType_GreasePencilArmature
static ImplicitSharingPtrAndData save_shared_attribute(const bke::GAttributeReader &attribute)
BMesh const char void * data
static void free_data(ModifierData *md)
static void panel_register(ARegionType *region_type)
void BKE_armature_deform_coords_with_curves(const Object &ob_arm, const Object &ob_target, const ListBaseT< bDeformGroup > *defbase, MutableSpan< float3 > vert_coords, std::optional< Span< float3 > > vert_coords_prev, std::optional< MutableSpan< float3x3 > > vert_deform_mats, Span< MDeformVert > dverts, int deformflag, StringRefNull defgrp_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)
VecBase< float, 3 > float3
static bool is_disabled(const Scene *, ModifierData *md, bool)
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
ListBaseT< struct bDeformGroup > vertex_group_names
ui::Layout * layout
GeometryComponent & get_component_for_write(GeometryComponent::Type component_type)
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)
Layout & column(bool align)
#define N_(msgid)