Blender V5.3
MOD_hook.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_utildefines.hh"
10
11#include "BLI_bitmap.hh"
12#include "BLI_math_matrix_c.hh"
13#include "BLI_math_vector_c.hh"
14
15#include "BLT_translation.hh"
16
17#include "DNA_color_types.h"
18#include "DNA_mesh_types.h"
19#include "DNA_meshdata_types.h"
20#include "DNA_object_types.h"
21#include "DNA_screen_types.h"
22
23#include "BKE_action.hh"
24#include "BKE_colortools.hh"
25#include "BKE_deform.hh"
26#include "BKE_editmesh.hh"
27#include "BKE_lib_query.hh"
28#include "BKE_mesh.hh"
29#include "BKE_modifier.hh"
30#include "BKE_object_types.hh"
31
32#include "UI_interface.hh"
34#include "UI_resources.hh"
35
36#include "BLO_read_write.hh"
37
38#include "RNA_access.hh"
39#include "RNA_prototypes.hh"
40
41#include "MEM_guardedalloc.h"
42
43#include "MOD_ui_common.hh"
44#include "MOD_util.hh"
45
46namespace blender {
47
48static void init_data(ModifierData *md)
49{
50 HookModifierData *hmd = reinterpret_cast<HookModifierData *>(md);
52
53 hmd->curfalloff = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
54}
55
56static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
57{
58 const HookModifierData *hmd = reinterpret_cast<const HookModifierData *>(md);
59 HookModifierData *thmd = reinterpret_cast<HookModifierData *>(target);
60
61 BKE_modifier_copydata_generic(md, target, flag);
62
64
65 thmd->indexar = MEM_dupalloc(hmd->indexar);
66}
67
68static void required_data_mask(ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
69{
70 HookModifierData *hmd = reinterpret_cast<HookModifierData *>(md);
71
72 /* Ask for vertex-groups if we need them. */
73 if (hmd->name[0] != '\0') {
74 r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
75 }
76 if (hmd->indexar != nullptr) {
77 /* TODO: check which origindex are actually needed? */
78 r_cddata_masks->vmask |= CD_MASK_ORIGINDEX;
79 r_cddata_masks->emask |= CD_MASK_ORIGINDEX;
80 r_cddata_masks->pmask |= CD_MASK_ORIGINDEX;
81 }
82}
83
84static void free_data(ModifierData *md)
85{
86 HookModifierData *hmd = reinterpret_cast<HookModifierData *>(md);
87
89
90 MEM_SAFE_DELETE(hmd->indexar);
91}
92
93static bool is_disabled(const Scene * /*scene*/, ModifierData *md, bool /*use_render_params*/)
94{
95 HookModifierData *hmd = reinterpret_cast<HookModifierData *>(md);
96
97 return !hmd->object;
98}
99
100static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
101{
102 HookModifierData *hmd = reinterpret_cast<HookModifierData *>(md);
103
104 walk(user_data, ob, reinterpret_cast<ID **>(&hmd->object), IDWALK_CB_NOP);
105}
106
108{
109 HookModifierData *hmd = reinterpret_cast<HookModifierData *>(md);
110 if (hmd->object != nullptr) {
111 if (hmd->subtarget[0]) {
113 ctx->node, hmd->object, hmd->subtarget, DEG_OB_COMP_BONE, "Hook Modifier");
114 }
115 DEG_add_object_relation(ctx->node, hmd->object, DEG_OB_COMP_TRANSFORM, "Hook Modifier");
116 }
117 /* We need our own transformation as well. */
118 DEG_add_depends_on_transform_relation(ctx->node, "Hook Modifier");
119}
120
147
149{
150 BLI_bitmap *indexar_used = BLI_BITMAP_NEW(verts_num, __func__);
151 int i;
152 int *index_pt;
153 for (i = 0, index_pt = hmd->indexar; i < hmd->indexar_num; i++, index_pt++) {
154 const int j = *index_pt;
155 if (j < verts_num) {
156 BLI_BITMAP_ENABLE(indexar_used, i);
157 }
158 }
159 return indexar_used;
160}
161
162static float hook_falloff(const HookData_cb *hd, const float len_sq)
163{
165 if (len_sq > hd->falloff_sq) {
166 return 0.0f;
167 }
168 if (len_sq > 0.0f) {
169 float fac;
170
172 fac = 1.0f;
173 goto finally;
174 }
175 else if (hd->falloff_type == eHook_Falloff_InvSquare) {
176 /* Avoid `sqrt` below. */
177 fac = 1.0f - (len_sq / hd->falloff_sq);
178 goto finally;
179 }
180
181 fac = 1.0f - (sqrtf(len_sq) / hd->falloff);
182
183 /* closely match PROP_SMOOTH and similar */
184 switch (hd->falloff_type) {
185#if 0
187 fac = 1.0f;
188 break;
189#endif
191 fac = BKE_curvemapping_evaluateF(hd->curfalloff, 0, fac);
192 break;
194 fac = fac * fac;
195 break;
197 fac = 3.0f * fac * fac - 2.0f * fac * fac * fac;
198 break;
200 fac = sqrtf(fac);
201 break;
203 /* pass */
204 break;
205#if 0
207 fac = 1.0f;
208 break;
209#endif
211 fac = sqrtf(2 * fac - fac * fac);
212 break;
213#if 0
215 fac = fac * (2.0f - fac);
216 break;
217#endif
218 }
219
220 finally:
221 return fac * hd->fac_orig;
222 }
223 else {
224 return hd->fac_orig;
225 }
226}
227
228static void hook_co_apply(HookData_cb *hd, int j, const MDeformVert *dv)
229{
230 float *co = hd->positions[j];
231 float fac;
232
233 if (hd->use_falloff) {
234 float len_sq;
235
236 if (hd->use_uniform) {
237 float co_uniform[3];
238 mul_v3_m3v3(co_uniform, hd->mat_uniform, co);
239 len_sq = len_squared_v3v3(hd->cent, co_uniform);
240 }
241 else {
242 len_sq = len_squared_v3v3(hd->cent, co);
243 }
244
245 fac = hook_falloff(hd, len_sq);
246 }
247 else {
248 fac = hd->fac_orig;
249 }
250
251 if (fac) {
252 if (dv != nullptr) {
253 fac *= hd->invert_vgroup ? 1.0f - BKE_defvert_find_weight(dv, hd->defgrp_index) :
255 }
256
257 if (fac) {
258 float co_tmp[3];
259 mul_v3_m4v3(co_tmp, hd->mat, co);
260 interp_v3_v3v3(co, co, co_tmp, fac);
261 }
262 }
263}
264
266 const ModifierEvalContext * /*ctx*/,
267 Object *ob,
268 Mesh *mesh,
269 const BMesh *bm,
270 MutableSpan<float3> positions)
271{
272 Object *ob_target = hmd->object;
273 bPoseChannel *pchan = BKE_pose_channel_find_name(ob_target->pose, hmd->subtarget);
274 float dmat[4][4];
275 int i, *index_pt;
276 const MDeformVert *dvert;
277 HookData_cb hd;
278 const bool invert_vgroup = (hmd->flag & MOD_HOOK_INVERT_VGROUP) != 0;
279
280 if (hmd->curfalloff == nullptr) {
281 /* should never happen, but bad lib linking could cause it */
282 hmd->curfalloff = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
283 }
284
285 if (hmd->curfalloff) {
287 }
288
289 /* Generic data needed for applying per-vertex calculations (initialize all members) */
290 hd.positions = positions;
291
292 MOD_get_vgroup(ob, mesh, hmd->name, &dvert, &hd.defgrp_index);
293 int cd_dvert_offset = -1;
294
295 if (hd.defgrp_index != -1) {
296 /* Edit-mesh. */
297 if (bm != nullptr) {
298 cd_dvert_offset = CustomData_get_offset(&bm->vdata, CD_MDEFORMVERT);
299 if (cd_dvert_offset == -1) {
300 hd.defgrp_index = -1;
301 }
302 }
303 else {
304 /* Regular mesh. */
305 if (dvert == nullptr) {
306 hd.defgrp_index = -1;
307 }
308 }
309 }
310
311 hd.curfalloff = hmd->curfalloff;
312
313 hd.falloff_type = hmd->falloff_type;
314 hd.falloff = (hmd->falloff_type == eHook_Falloff_None) ? 0.0f : hmd->falloff;
315 hd.falloff_sq = square_f(hd.falloff);
316 hd.fac_orig = hmd->force;
317
318 hd.use_falloff = (hd.falloff_sq != 0.0f);
319 hd.use_uniform = (hmd->flag & MOD_HOOK_UNIFORM_SPACE) != 0;
320
321 hd.invert_vgroup = invert_vgroup;
322
323 if (hd.use_uniform) {
325 mul_v3_m3v3(hd.cent, hd.mat_uniform, hmd->cent);
326 }
327 else {
328 unit_m3(hd.mat_uniform); /* unused */
329 copy_v3_v3(hd.cent, hmd->cent);
330 }
331
332 /* get world-space matrix of target, corrected for the space the verts are in */
333 if (hmd->subtarget[0] && pchan) {
334 /* bone target if there's a matching pose-channel */
335 mul_m4_m4m4(dmat, ob_target->object_to_world().ptr(), pchan->pose_mat);
336 }
337 else {
338 /* just object target */
339 copy_m4_m4(dmat, ob_target->object_to_world().ptr());
340 }
341 invert_m4_m4(ob->runtime->world_to_object.ptr(), ob->object_to_world().ptr());
342 mul_m4_series(hd.mat, ob->world_to_object().ptr(), dmat, hmd->parentinv);
343 /* --- done with 'hd' init --- */
344
345 /* Regarding index range checking below.
346 *
347 * This should always be true and I don't generally like
348 * "paranoid" style code like this, but old files can have
349 * indices that are out of range because old blender did
350 * not correct them on exit edit-mode. - zr
351 */
352
353 if (hmd->force == 0.0f) {
354 /* do nothing, avoid annoying checks in the loop */
355 }
356 else if (hmd->indexar) { /* vertex indices? */
357 const int *origindex_ar;
358 /* if mesh is present and has original index data, use it */
359 if (mesh && (origindex_ar = static_cast<const int *>(
360 CustomData_get_layer(&mesh->vert_data, CD_ORIGINDEX))))
361 {
362 int verts_orig_num = positions.size();
363 if (ob->type == OB_MESH) {
364 const Mesh *me_orig = id_cast<const Mesh *>(ob->data);
365 verts_orig_num = me_orig->verts_num;
366 }
367 BLI_bitmap *indexar_used = hook_index_array_to_bitmap(hmd, verts_orig_num);
368 for (i = 0; i < positions.size(); i++) {
369 int i_orig = origindex_ar[i];
370 BLI_assert(i_orig < verts_orig_num);
371 if (BLI_BITMAP_TEST(indexar_used, i_orig)) {
372 hook_co_apply(&hd, i, dvert ? &dvert[i] : nullptr);
373 }
374 }
375 MEM_delete(indexar_used);
376 }
377 else { /* missing mesh or ORIGINDEX */
378 if ((bm != nullptr) && (hd.defgrp_index != -1)) {
379 BLI_assert(bm->totvert == positions.size());
380 BLI_bitmap *indexar_used = hook_index_array_to_bitmap(hmd, positions.size());
381 BMIter iter;
382 BMVert *v;
383 BM_ITER_MESH_INDEX (v, &iter, const_cast<BMesh *>(bm), BM_VERTS_OF_MESH, i) {
384 if (BLI_BITMAP_TEST(indexar_used, i)) {
385 const MDeformVert *dv = static_cast<const MDeformVert *>(
386 BM_ELEM_CD_GET_VOID_P(v, cd_dvert_offset));
387 hook_co_apply(&hd, i, dv);
388 }
389 }
390 MEM_delete(indexar_used);
391 }
392 else {
393 for (i = 0, index_pt = hmd->indexar; i < hmd->indexar_num; i++, index_pt++) {
394 const int j = *index_pt;
395 if (j < positions.size()) {
396 hook_co_apply(&hd, j, dvert ? &dvert[j] : nullptr);
397 }
398 }
399 }
400 }
401 }
402 else if (hd.defgrp_index != -1) { /* vertex group hook */
403 if (bm != nullptr) {
404 BLI_assert(bm->totvert == positions.size());
405 BMIter iter;
406 BMVert *v;
407 BM_ITER_MESH_INDEX (v, &iter, const_cast<BMesh *>(bm), BM_VERTS_OF_MESH, i) {
408 const MDeformVert *dv = static_cast<const MDeformVert *>(
409 BM_ELEM_CD_GET_VOID_P(v, cd_dvert_offset));
410 hook_co_apply(&hd, i, dv);
411 }
412 }
413 else {
414 BLI_assert(dvert != nullptr);
415 for (i = 0; i < positions.size(); i++) {
416 hook_co_apply(&hd, i, &dvert[i]);
417 }
418 }
419 }
420}
421
423 const ModifierEvalContext *ctx,
424 Mesh *mesh,
425 MutableSpan<float3> positions)
426{
427 HookModifierData *hmd = reinterpret_cast<HookModifierData *>(md);
428 deformVerts_do(hmd, ctx, ctx->object, mesh, nullptr, positions);
429}
430
432 const ModifierEvalContext *ctx,
433 Mesh *mesh,
434 MutableSpan<float3> positions)
435{
436 HookModifierData *hmd = reinterpret_cast<HookModifierData *>(md);
437
438 deformVerts_do(hmd,
439 ctx,
440 ctx->object,
441 mesh,
442 mesh->runtime->wrapper_type == ME_WRAPPER_TYPE_BMESH ?
444 nullptr,
445 positions);
446}
447
448static void panel_draw(const bContext * /*C*/, Panel *panel)
449{
450 ui::Layout &layout = *panel->layout;
451
452 PointerRNA ob_ptr;
454
455 PointerRNA hook_object_ptr = RNA_pointer_get(ptr, "object");
456
457 layout.use_property_split_set(true);
458
459 ui::Layout &col = layout.column(false);
460 col.prop(ptr, "object", UI_ITEM_NONE, std::nullopt, ICON_NONE);
461 if (hook_object_ptr && RNA_enum_get(&hook_object_ptr, "type") == OB_ARMATURE) {
462 PointerRNA hook_object_data_ptr = RNA_pointer_get(&hook_object_ptr, "data");
463 col.prop_search(ptr, "subtarget", &hook_object_data_ptr, "bones", IFACE_("Bone"), ICON_NONE);
464 }
465 modifier_vgroup_ui(layout, ptr, &ob_ptr, "vertex_group", "invert_vertex_group", std::nullopt);
466
467 layout.prop(ptr, "strength", ui::ITEM_R_SLIDER, std::nullopt, ICON_NONE);
468
469 if (RNA_enum_get(&ob_ptr, "mode") == OB_MODE_EDIT) {
470 ui::Layout *row = &layout.row(true);
471 row->op("OBJECT_OT_hook_reset", IFACE_("Reset"), ICON_NONE);
472 row->op("OBJECT_OT_hook_recenter", IFACE_("Recenter"), ICON_NONE);
473 row = &layout.row(true);
474 row->op("OBJECT_OT_hook_select", IFACE_("Select"), ICON_NONE);
475 row->op("OBJECT_OT_hook_assign", IFACE_("Assign"), ICON_NONE);
476 }
477
478 modifier_error_message_draw(layout, ptr);
479}
480
481static void falloff_panel_draw(const bContext * /*C*/, Panel *panel)
482{
483 ui::Layout &layout = *panel->layout;
484
486
487 bool use_falloff = RNA_enum_get(ptr, "falloff_type") != eWarp_Falloff_None;
488
489 layout.use_property_split_set(true);
490
491 layout.prop(ptr, "falloff_type", UI_ITEM_NONE, IFACE_("Type"), ICON_NONE);
492
493 ui::Layout &row = layout.row(false);
494 row.active_set(use_falloff);
495 row.prop(ptr, "falloff_radius", UI_ITEM_NONE, std::nullopt, ICON_NONE);
496
497 layout.prop(ptr, "use_falloff_uniform", UI_ITEM_NONE, std::nullopt, ICON_NONE);
498
499 if (RNA_enum_get(ptr, "falloff_type") == eWarp_Falloff_Curve) {
500 template_curve_mapping(&layout, ptr, "falloff_curve", 0, false, false, false, false, false);
501 }
502}
503
504static void panel_register(ARegionType *region_type)
505{
508 region_type, "falloff", "Falloff", nullptr, falloff_panel_draw, panel_type);
509}
510
511static void blend_write(BlendWriter *writer, const ID * /*id_owner*/, const ModifierData *md)
512{
513 const HookModifierData *hmd = reinterpret_cast<const HookModifierData *>(md);
514
515 writer->write_struct(hmd);
516
517 if (hmd->curfalloff) {
519 }
520
521 writer->write_int32_array(hmd->indexar_num, hmd->indexar);
522}
523
524static void blend_read(BlendDataReader *reader, ModifierData *md)
525{
526 HookModifierData *hmd = reinterpret_cast<HookModifierData *>(md);
527
529 if (hmd->curfalloff) {
531 }
532
534}
535
537 /*idname*/ "Hook",
538 /*name*/ N_("Hook"),
539 /*struct_name*/ "HookModifierData",
540 /*struct_size*/ sizeof(HookModifierData),
541 /*srna*/ &RNA_HookModifier,
545 /*icon*/ ICON_HOOK,
546 /*copy_data*/ copy_data,
547
548 /*deform_verts*/ deform_verts,
549 /*deform_matrices*/ nullptr,
550 /*deform_verts_EM*/ deform_verts_EM,
551 /*deform_matrices_EM*/ nullptr,
552 /*modify_mesh*/ nullptr,
553 /*modify_geometry_set*/ nullptr,
554
555 /*init_data*/ init_data,
556 /*required_data_mask*/ required_data_mask,
557 /*free_data*/ free_data,
558 /*is_disabled*/ is_disabled,
559 /*update_depsgraph*/ update_depsgraph,
560 /*depends_on_time*/ nullptr,
561 /*depends_on_normals*/ nullptr,
562 /*foreach_ID_link*/ foreach_ID_link,
563 /*foreach_tex_link*/ nullptr,
564 /*free_runtime_data*/ nullptr,
565 /*panel_register*/ panel_register,
566 /*blend_write*/ blend_write,
567 /*blend_read*/ blend_read,
568 /*foreach_cache*/ nullptr,
569 /*foreach_working_space_color*/ nullptr,
570};
571
572} // namespace blender
Blender kernel action and pose functionality.
support for deformation groups and hooks.
#define BLI_BITMAP_NEW(_num, _alloc_string)
Definition BLI_bitmap.hh:39
#define BLI_BITMAP_TEST(_bitmap, _index)
Definition BLI_bitmap.hh:63
#define BLI_BITMAP_ENABLE(_bitmap, _index)
Definition BLI_bitmap.hh:80
#define mul_m4_series(...)
#define BLO_read_struct(reader, struct_name, ptr_p)
#define IFACE_(msgid)
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define UI_ITEM_NONE
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
#define BM_ELEM_CD_GET_VOID_P(ele, offset)
#define BM_ITER_MESH_INDEX(ele, iter, bm, itype, indexvar)
#define CD_MASK_ORIGINDEX
#define CD_MASK_MDEFORMVERT
constexpr int64_t size() const
Definition BLI_span.hh:499
BMesh Iterators.
CurveMapping * BKE_curvemapping_add(int tot, float minx, float miny, float maxx, float maxy)
Definition colortools.cc:99
int CustomData_get_offset(const CustomData *data, eCustomDataType type)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
MINLINE float len_squared_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
CurveMapping * BKE_curvemapping_copy(const CurveMapping *cumap)
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)
MINLINE void copy_v3_v3(float r[3], const float a[3])
unsigned int uint
Definition BKE_text.h:55
void copy_m3_m4(float m1[3][3], const float m2[4][4])
void mul_v3_m4v3(float r[3], const float mat[4][4], const float vec[3])
void MOD_get_vgroup(const Object *ob, const Mesh *mesh, const char *name, const MDeformVert **dvert, int *defgrp_index)
Definition MOD_util.cc:158
bool invert_m4_m4(float inverse[4][4], const float mat[4][4])
static void init_data(ModifierData *md)
void(*)(void *user_data, Object *ob, ID **idpoin, LibraryForeachIDCallbackFlag cb_flag) IDWalkFunc
static void update_depsgraph(tGraphSliderOp *gso)
ModifierTypeInfo modifierType_Hook
Definition MOD_hook.cc:536
void BKE_curvemapping_blend_write(BlendWriter *writer, const CurveMapping *cumap)
static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
ATTR_WARN_UNUSED_RESULT const BMVert * v
void DEG_add_object_relation(DepsNodeHandle *node_handle, Object *object, eDepsObjectComponentType component, const char *description)
static void hook_co_apply(HookData_cb *hd, int j, const MDeformVert *dv)
Definition MOD_hook.cc:228
void BKE_curvemapping_free(CurveMapping *cumap)
void DEG_add_bone_relation(DepsNodeHandle *handle, Object *object, const char *bone_name, eDepsObjectComponentType component, const char *description)
void DEG_add_depends_on_transform_relation(DepsNodeHandle *node_handle, const char *description)
static void required_data_mask(ModifierData *, CustomData_MeshMasks *r_cddata_masks)
static BLI_bitmap * hook_index_array_to_bitmap(HookModifierData *hmd, const int verts_num)
Definition MOD_hook.cc:148
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
void BKE_curvemapping_init(CurveMapping *cumap)
float BKE_defvert_find_weight(const MDeformVert *dvert, int defgroup)
Definition deform.cc:779
void BKE_curvemapping_blend_read(BlendDataReader *reader, CurveMapping *cumap)
void modifier_vgroup_ui(ui::Layout &layout, PointerRNA *ptr, PointerRNA *ob_ptr, const StringRefNull vgroup_prop, const std::optional< StringRefNull > invert_vgroup_prop, const std::optional< StringRefNull > text)
static void deform_verts_EM(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh, MutableSpan< float3 > positions)
static void free_data(ModifierData *md)
Definition MOD_hook.cc:84
static void panel_register(ARegionType *region_type)
void interp_v3_v3v3(float r[3], const float a[3], const float b[3], float t)
const void * CustomData_get_layer(const CustomData *data, eCustomDataType type)
@ eModifierTypeFlag_AcceptsCVs
@ eModifierTypeFlag_SupportsEditmode
@ eModifierTypeFlag_AcceptsVertexCosOnly
PointerRNA RNA_pointer_get(PointerRNA *ptr, const char *name)
void BLO_read_array_and_validate_size(BlendDataReader *reader, T **ptr_p, SizeT *array_size, const int elems=1)
static void blend_read(BlendDataReader *, ModifierData *md)
static float hook_falloff(const float falloff, const int falloff_type, const float falloff_sq, const float fac_orig, const CurveMapping *curfalloff, const float len_sq)
unsigned int BLI_bitmap
Definition BLI_bitmap.hh:15
void unit_m3(float m[3][3])
static void deformVerts_do(HookModifierData *hmd, const ModifierEvalContext *, Object *ob, Mesh *mesh, const BMesh *bm, MutableSpan< float3 > positions)
Definition MOD_hook.cc:265
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
MINLINE float square_f(float a)
const BMesh * BKE_editmesh_bmesh_get(const Object *ob)
Definition editmesh.cc:65
static void panel_draw(const bContext *, Panel *panel)
PanelType * modifier_subpanel_register(ARegionType *region_type, const char *name, const char *label, PanelDrawFn draw_header, PanelDrawFn draw, PanelType *parent)
static void deform_verts(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh, MutableSpan< float3 > positions)
void copy_m4_m4(float m1[4][4], const float m2[4][4])
@ ME_WRAPPER_TYPE_BMESH
static bool is_disabled(const Scene *, ModifierData *md, bool)
void mul_v3_m3v3(float r[3], const float M[3][3], const float a[3])
static void falloff_panel_draw(const bContext *, Panel *panel)
Definition MOD_hook.cc:481
float BKE_curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value)
bPoseChannel * BKE_pose_channel_find_name(const bPose *pose, const char *name)
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
#define sqrtf
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
void write_int32_array(int64_t num, const int32_t *data)
float mat_uniform[3][3]
Definition MOD_hook.cc:142
MutableSpan< float3 > positions
Definition MOD_hook.cc:122
CurveMapping * curfalloff
Definition MOD_hook.cc:130
HookModifierFalloff falloff_type
struct CurveMapping * curfalloff
const c_style_mat & ptr() const
bke::ObjectRuntime * runtime
struct bPose * pose
ui::Layout * layout
void prop_search(PointerRNA *ptr, PropertyRNA *prop, PointerRNA *searchptr, PropertyRNA *searchprop, PropertyRNA *item_searchpropname, std::optional< StringRefNull > name, int icon, bool results_are_suggestions)
void use_property_split_set(bool is_sep)
PointerRNA op(wmOperatorType *ot, std::optional< StringRef > name, int icon, wm::OpCallContext context, eUI_Item_Flag flag)
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)
Layout & row(bool align)
#define N_(msgid)