Blender V5.3
MOD_laplaciandeform.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2013 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BLI_utildefines.hh"
10
11#include "BLI_math_geom_c.hh"
12#include "BLI_math_vector_c.hh"
13#include "BLI_string.hh"
15
16#include "MEM_guardedalloc.h"
17
18#include "BLT_translation.hh"
19
20#include "DNA_mesh_types.h"
21#include "DNA_meshdata_types.h"
22#include "DNA_screen_types.h"
23
24#include "BKE_deform.hh"
25#include "BKE_mesh_mapping.hh"
26
28#include "UI_resources.hh"
29
30#include "BLO_read_write.hh"
31
32#include "RNA_access.hh"
33#include "RNA_prototypes.hh"
34
35#include "MOD_ui_common.hh"
36#include "MOD_util.hh"
37
38#include "eigen_capi.h"
39
40namespace blender {
41
42enum {
51};
52
53namespace {
54
55struct LaplacianSystem {
56 bool is_matrix_computed;
57 bool has_solution;
58 int verts_num;
59 int edges_num;
60 int tris_num;
61 int anchors_num;
62 int repeat;
64 char anchor_grp_name[/*MAX_VGROUP_NAME*/ 64];
66 float (*co)[3];
68 float (*no)[3];
70 float (*delta)[3];
76 uint (*tris)[3];
78 int *index_anchors;
80 int *unit_verts;
82 int *ringf_indices;
84 int *ringv_indices;
88 MeshElemMap *ringf_map;
90 MeshElemMap *ringv_map;
91};
92
93}; // namespace
94
96{
98
99 sys->is_matrix_computed = false;
100 sys->has_solution = false;
101 sys->verts_num = 0;
102 sys->edges_num = 0;
103 sys->anchors_num = 0;
104 sys->tris_num = 0;
105 sys->repeat = 1;
106 sys->anchor_grp_name[0] = '\0';
107
108 return sys;
109}
110
112 int edges_num,
113 int tris_num,
114 int anchors_num,
115 const char defgrpName[64],
116 int iterations)
117{
119
120 sys->is_matrix_computed = false;
121 sys->has_solution = false;
122 sys->verts_num = verts_num;
123 sys->edges_num = edges_num;
124 sys->tris_num = tris_num;
125 sys->anchors_num = anchors_num;
126 sys->repeat = iterations;
127 STRNCPY(sys->anchor_grp_name, defgrpName);
128 sys->co = MEM_new_array_uninitialized<float[3]>(size_t(verts_num), __func__);
129 sys->no = MEM_new_array_zeroed<float[3]>(verts_num, __func__);
130 sys->delta = MEM_new_array_zeroed<float[3]>(verts_num, __func__);
131 sys->tris = MEM_new_array_uninitialized<uint[3]>(size_t(tris_num), __func__);
132 sys->index_anchors = MEM_new_array_uninitialized<int>(size_t(anchors_num), __func__);
133 sys->unit_verts = MEM_new_array_zeroed<int>(verts_num, __func__);
134 return sys;
135}
136
138{
139 MEM_SAFE_DELETE(sys->co);
140 MEM_SAFE_DELETE(sys->no);
141 MEM_SAFE_DELETE(sys->delta);
142 MEM_SAFE_DELETE(sys->tris);
143 MEM_SAFE_DELETE(sys->index_anchors);
144 MEM_SAFE_DELETE(sys->unit_verts);
145 MEM_SAFE_DELETE(sys->ringf_indices);
146 MEM_SAFE_DELETE(sys->ringv_indices);
147 MEM_SAFE_DELETE(sys->ringf_map);
148 MEM_SAFE_DELETE(sys->ringv_map);
149
150 if (sys->context) {
151 EIG_linear_solver_delete(sys->context);
152 }
153 MEM_SAFE_DELETE(sys);
154}
155
156static void createFaceRingMap(const int mvert_tot,
157 Span<int3> corner_tris,
158 Span<int> corner_verts,
159 MeshElemMap **r_map,
160 int **r_indices)
161{
162 int indices_num = 0;
163 int *indices, *index_iter;
164 MeshElemMap *map = MEM_new_array_zeroed<MeshElemMap>(mvert_tot, __func__);
165
166 for (const int i : corner_tris.index_range()) {
167 const int3 &tri = corner_tris[i];
168 for (int j = 0; j < 3; j++) {
169 const int v_index = corner_verts[tri[j]];
170 map[v_index].count++;
171 indices_num++;
172 }
173 }
174 indices = MEM_new_array_zeroed<int>(indices_num, __func__);
175 index_iter = indices;
176 for (int i = 0; i < mvert_tot; i++) {
177 map[i].indices = index_iter;
178 index_iter += map[i].count;
179 map[i].count = 0;
180 }
181 for (const int i : corner_tris.index_range()) {
182 const int3 &tri = corner_tris[i];
183 for (int j = 0; j < 3; j++) {
184 const int v_index = corner_verts[tri[j]];
185 map[v_index].indices[map[v_index].count] = i;
186 map[v_index].count++;
187 }
188 }
189 *r_map = map;
190 *r_indices = indices;
191}
192
193static void createVertRingMap(const int mvert_tot,
194 const Span<int2> edges,
195 MeshElemMap **r_map,
196 int **r_indices)
197{
198 MeshElemMap *map = MEM_new_array_zeroed<MeshElemMap>(mvert_tot, __func__);
199 int i, vid[2], indices_num = 0;
200 int *indices, *index_iter;
201
202 for (const int i : edges.index_range()) {
203 vid[0] = edges[i][0];
204 vid[1] = edges[i][1];
205 map[vid[0]].count++;
206 map[vid[1]].count++;
207 indices_num += 2;
208 }
209 indices = MEM_new_array_zeroed<int>(indices_num, __func__);
210 index_iter = indices;
211 for (i = 0; i < mvert_tot; i++) {
212 map[i].indices = index_iter;
213 index_iter += map[i].count;
214 map[i].count = 0;
215 }
216 for (const int i : edges.index_range()) {
217 vid[0] = edges[i][0];
218 vid[1] = edges[i][1];
219 map[vid[0]].indices[map[vid[0]].count] = vid[1];
220 map[vid[0]].count++;
221 map[vid[1]].indices[map[vid[1]].count] = vid[0];
222 map[vid[1]].count++;
223 }
224 *r_map = map;
225 *r_indices = indices;
226}
227
261{
262 float no[3];
263 float w2, w3;
264 int i = 3, j, ti;
265 int idv[3];
266
267 for (ti = 0; ti < sys->tris_num; ti++) {
268 const uint *vidt = sys->tris[ti];
269 const float *co[3];
270
271 co[0] = sys->co[vidt[0]];
272 co[1] = sys->co[vidt[1]];
273 co[2] = sys->co[vidt[2]];
274
275 normal_tri_v3(no, UNPACK3(co));
276 add_v3_v3(sys->no[vidt[0]], no);
277 add_v3_v3(sys->no[vidt[1]], no);
278 add_v3_v3(sys->no[vidt[2]], no);
279
280 for (j = 0; j < 3; j++) {
281 const float *v1, *v2, *v3;
282
283 idv[0] = vidt[j];
284 idv[1] = vidt[(j + 1) % i];
285 idv[2] = vidt[(j + 2) % i];
286
287 v1 = sys->co[idv[0]];
288 v2 = sys->co[idv[1]];
289 v3 = sys->co[idv[2]];
290
291 w2 = cotangent_tri_weight_v3(v3, v1, v2);
292 w3 = cotangent_tri_weight_v3(v2, v3, v1);
293
294 sys->delta[idv[0]][0] += v1[0] * (w2 + w3);
295 sys->delta[idv[0]][1] += v1[1] * (w2 + w3);
296 sys->delta[idv[0]][2] += v1[2] * (w2 + w3);
297
298 sys->delta[idv[0]][0] -= v2[0] * w2;
299 sys->delta[idv[0]][1] -= v2[1] * w2;
300 sys->delta[idv[0]][2] -= v2[2] * w2;
301
302 sys->delta[idv[0]][0] -= v3[0] * w3;
303 sys->delta[idv[0]][1] -= v3[1] * w3;
304 sys->delta[idv[0]][2] -= v3[2] * w3;
305
306 EIG_linear_solver_matrix_add(sys->context, idv[0], idv[1], -w2);
307 EIG_linear_solver_matrix_add(sys->context, idv[0], idv[2], -w3);
308 EIG_linear_solver_matrix_add(sys->context, idv[0], idv[0], w2 + w3);
309 }
310 }
311}
312
314{
315 int vid, *vidn = nullptr;
316 float minj, mjt, qj[3], vj[3];
317 int i, j, ln;
318
319 for (i = 0; i < sys->verts_num; i++) {
320 normalize_v3(sys->no[i]);
321 vidn = sys->ringv_map[i].indices;
322 ln = sys->ringv_map[i].count;
323 minj = 1000000.0f;
324 for (j = 0; j < ln; j++) {
325 vid = vidn[j];
326 copy_v3_v3(qj, sys->co[vid]);
327 sub_v3_v3v3(vj, qj, sys->co[i]);
328 normalize_v3(vj);
329 mjt = fabsf(dot_v3v3(vj, sys->no[i]));
330 if (mjt < minj) {
331 minj = mjt;
332 sys->unit_verts[i] = vidn[j];
333 }
334 }
335 }
336}
337
339{
340 float alpha, beta, gamma;
341 float pj[3], ni[3], di[3];
342 float uij[3], dun[3], e2[3], pi[3], fni[3], vn[3][3];
343 int i, j, fidn_num, k, fi;
344 int *fidn;
345
346 for (i = 0; i < sys->verts_num; i++) {
347 copy_v3_v3(pi, sys->co[i]);
348 copy_v3_v3(ni, sys->no[i]);
349 k = sys->unit_verts[i];
350 copy_v3_v3(pj, sys->co[k]);
351 sub_v3_v3v3(uij, pj, pi);
352 mul_v3_v3fl(dun, ni, dot_v3v3(uij, ni));
353 sub_v3_v3(uij, dun);
354 normalize_v3(uij);
355 cross_v3_v3v3(e2, ni, uij);
356 copy_v3_v3(di, sys->delta[i]);
357 alpha = dot_v3v3(ni, di);
358 beta = dot_v3v3(uij, di);
359 gamma = dot_v3v3(e2, di);
360
361 pi[0] = EIG_linear_solver_variable_get(sys->context, 0, i);
362 pi[1] = EIG_linear_solver_variable_get(sys->context, 1, i);
363 pi[2] = EIG_linear_solver_variable_get(sys->context, 2, i);
364 zero_v3(ni);
365 fidn_num = sys->ringf_map[i].count;
366 for (fi = 0; fi < fidn_num; fi++) {
367 const uint *vin;
368 fidn = sys->ringf_map[i].indices;
369 vin = sys->tris[fidn[fi]];
370 for (j = 0; j < 3; j++) {
371 vn[j][0] = EIG_linear_solver_variable_get(sys->context, 0, vin[j]);
372 vn[j][1] = EIG_linear_solver_variable_get(sys->context, 1, vin[j]);
373 vn[j][2] = EIG_linear_solver_variable_get(sys->context, 2, vin[j]);
374 if (vin[j] == sys->unit_verts[i]) {
375 copy_v3_v3(pj, vn[j]);
376 }
377 }
378
379 normal_tri_v3(fni, UNPACK3(vn));
380 add_v3_v3(ni, fni);
381 }
382
383 normalize_v3(ni);
384 sub_v3_v3v3(uij, pj, pi);
385 mul_v3_v3fl(dun, ni, dot_v3v3(uij, ni));
386 sub_v3_v3(uij, dun);
387 normalize_v3(uij);
388 cross_v3_v3v3(e2, ni, uij);
389 fni[0] = alpha * ni[0] + beta * uij[0] + gamma * e2[0];
390 fni[1] = alpha * ni[1] + beta * uij[1] + gamma * e2[1];
391 fni[2] = alpha * ni[2] + beta * uij[2] + gamma * e2[2];
392
393 if (len_squared_v3(fni) > FLT_EPSILON) {
394 EIG_linear_solver_right_hand_side_add(sys->context, 0, i, fni[0]);
395 EIG_linear_solver_right_hand_side_add(sys->context, 1, i, fni[1]);
396 EIG_linear_solver_right_hand_side_add(sys->context, 2, i, fni[2]);
397 }
398 else {
399 EIG_linear_solver_right_hand_side_add(sys->context, 0, i, sys->delta[i][0]);
400 EIG_linear_solver_right_hand_side_add(sys->context, 1, i, sys->delta[i][1]);
401 EIG_linear_solver_right_hand_side_add(sys->context, 2, i, sys->delta[i][2]);
402 }
403 }
404}
405
406static void laplacianDeformPreview(LaplacianSystem *sys, float (*vertexCos)[3])
407{
408 int vid, i, j, n, na;
409 n = sys->verts_num;
410 na = sys->anchors_num;
411
412 if (!sys->is_matrix_computed) {
413 sys->context = EIG_linear_least_squares_solver_new(n + na, n, 3);
414
415 for (i = 0; i < n; i++) {
416 EIG_linear_solver_variable_set(sys->context, 0, i, sys->co[i][0]);
417 EIG_linear_solver_variable_set(sys->context, 1, i, sys->co[i][1]);
418 EIG_linear_solver_variable_set(sys->context, 2, i, sys->co[i][2]);
419 }
420 for (i = 0; i < na; i++) {
421 vid = sys->index_anchors[i];
422 EIG_linear_solver_variable_set(sys->context, 0, vid, vertexCos[vid][0]);
423 EIG_linear_solver_variable_set(sys->context, 1, vid, vertexCos[vid][1]);
424 EIG_linear_solver_variable_set(sys->context, 2, vid, vertexCos[vid][2]);
425 }
426
429
430 for (i = 0; i < n; i++) {
431 EIG_linear_solver_right_hand_side_add(sys->context, 0, i, sys->delta[i][0]);
432 EIG_linear_solver_right_hand_side_add(sys->context, 1, i, sys->delta[i][1]);
433 EIG_linear_solver_right_hand_side_add(sys->context, 2, i, sys->delta[i][2]);
434 }
435 for (i = 0; i < na; i++) {
436 vid = sys->index_anchors[i];
437 EIG_linear_solver_right_hand_side_add(sys->context, 0, n + i, vertexCos[vid][0]);
438 EIG_linear_solver_right_hand_side_add(sys->context, 1, n + i, vertexCos[vid][1]);
439 EIG_linear_solver_right_hand_side_add(sys->context, 2, n + i, vertexCos[vid][2]);
440 EIG_linear_solver_matrix_add(sys->context, n + i, vid, 1.0f);
441 }
442 if (EIG_linear_solver_solve(sys->context)) {
443 sys->has_solution = true;
444
445 for (j = 1; j <= sys->repeat; j++) {
447
448 for (i = 0; i < na; i++) {
449 vid = sys->index_anchors[i];
450 EIG_linear_solver_right_hand_side_add(sys->context, 0, n + i, vertexCos[vid][0]);
451 EIG_linear_solver_right_hand_side_add(sys->context, 1, n + i, vertexCos[vid][1]);
452 EIG_linear_solver_right_hand_side_add(sys->context, 2, n + i, vertexCos[vid][2]);
453 }
454
455 if (!EIG_linear_solver_solve(sys->context)) {
456 sys->has_solution = false;
457 break;
458 }
459 }
460 if (sys->has_solution) {
461 for (vid = 0; vid < sys->verts_num; vid++) {
462 vertexCos[vid][0] = EIG_linear_solver_variable_get(sys->context, 0, vid);
463 vertexCos[vid][1] = EIG_linear_solver_variable_get(sys->context, 1, vid);
464 vertexCos[vid][2] = EIG_linear_solver_variable_get(sys->context, 2, vid);
465 }
466 }
467 else {
468 sys->has_solution = false;
469 }
470 }
471 else {
472 sys->has_solution = false;
473 }
474 sys->is_matrix_computed = true;
475 }
476 else if (sys->has_solution) {
477 for (i = 0; i < n; i++) {
478 EIG_linear_solver_right_hand_side_add(sys->context, 0, i, sys->delta[i][0]);
479 EIG_linear_solver_right_hand_side_add(sys->context, 1, i, sys->delta[i][1]);
480 EIG_linear_solver_right_hand_side_add(sys->context, 2, i, sys->delta[i][2]);
481 }
482 for (i = 0; i < na; i++) {
483 vid = sys->index_anchors[i];
484 EIG_linear_solver_right_hand_side_add(sys->context, 0, n + i, vertexCos[vid][0]);
485 EIG_linear_solver_right_hand_side_add(sys->context, 1, n + i, vertexCos[vid][1]);
486 EIG_linear_solver_right_hand_side_add(sys->context, 2, n + i, vertexCos[vid][2]);
487 EIG_linear_solver_matrix_add(sys->context, n + i, vid, 1.0f);
488 }
489
490 if (EIG_linear_solver_solve(sys->context)) {
491 sys->has_solution = true;
492 for (j = 1; j <= sys->repeat; j++) {
494
495 for (i = 0; i < na; i++) {
496 vid = sys->index_anchors[i];
497 EIG_linear_solver_right_hand_side_add(sys->context, 0, n + i, vertexCos[vid][0]);
498 EIG_linear_solver_right_hand_side_add(sys->context, 1, n + i, vertexCos[vid][1]);
499 EIG_linear_solver_right_hand_side_add(sys->context, 2, n + i, vertexCos[vid][2]);
500 }
501 if (!EIG_linear_solver_solve(sys->context)) {
502 sys->has_solution = false;
503 break;
504 }
505 }
506 if (sys->has_solution) {
507 for (vid = 0; vid < sys->verts_num; vid++) {
508 vertexCos[vid][0] = EIG_linear_solver_variable_get(sys->context, 0, vid);
509 vertexCos[vid][1] = EIG_linear_solver_variable_get(sys->context, 1, vid);
510 vertexCos[vid][2] = EIG_linear_solver_variable_get(sys->context, 2, vid);
511 }
512 }
513 else {
514 sys->has_solution = false;
515 }
516 }
517 else {
518 sys->has_solution = false;
519 }
520 }
521}
522
524{
525 int defgrp_index;
526 const MDeformVert *dvert = nullptr;
527
528 MOD_get_vgroup(ob, mesh, lmd->anchor_grp_name, &dvert, &defgrp_index);
529
530 return (dvert != nullptr);
531}
532
533static void initSystem(
534 LaplacianDeformModifierData *lmd, Object *ob, Mesh *mesh, float (*vertexCos)[3], int verts_num)
535{
536 int i;
537 int defgrp_index;
538 int anchors_num;
539 float wpaint;
540 const MDeformVert *dvert = nullptr;
541 const MDeformVert *dv = nullptr;
542 LaplacianSystem *sys;
543 const bool invert_vgroup = (lmd->flag & MOD_LAPLACIANDEFORM_INVERT_VGROUP) != 0;
544
545 if (isValidVertexGroup(lmd, ob, mesh)) {
546 int *index_anchors = MEM_new_array_uninitialized<int>(size_t(verts_num),
547 __func__); /* Over-allocate. */
548
549 STACK_DECLARE(index_anchors);
550
551 STACK_INIT(index_anchors, verts_num);
552
553 MOD_get_vgroup(ob, mesh, lmd->anchor_grp_name, &dvert, &defgrp_index);
554 BLI_assert(dvert != nullptr);
555 dv = dvert;
556 for (i = 0; i < verts_num; i++) {
557 wpaint = invert_vgroup ? 1.0f - BKE_defvert_find_weight(dv, defgrp_index) :
558 BKE_defvert_find_weight(dv, defgrp_index);
559 dv++;
560 if (wpaint > 0.0f) {
561 STACK_PUSH(index_anchors, i);
562 }
563 }
564
565 const Span<int2> edges = mesh->edges();
566 const Span<int> corner_verts = mesh->corner_verts();
567 const Span<int3> corner_tris = mesh->corner_tris();
568
569 anchors_num = STACK_SIZE(index_anchors);
570 lmd->cache_system = initLaplacianSystem(verts_num,
571 edges.size(),
572 corner_tris.size(),
573 anchors_num,
574 lmd->anchor_grp_name,
575 lmd->repeat);
576 sys = static_cast<LaplacianSystem *>(lmd->cache_system);
577 memcpy(sys->index_anchors, index_anchors, sizeof(int) * anchors_num);
578 memcpy(sys->co, vertexCos, sizeof(float[3]) * verts_num);
579 MEM_delete(index_anchors);
580 lmd->vertexco = MEM_new_array_uninitialized<float>(3 * size_t(verts_num), __func__);
582 memcpy(lmd->vertexco, vertexCos, sizeof(float[3]) * verts_num);
583 lmd->verts_num = verts_num;
584
586 mesh->verts_num, corner_tris, corner_verts, &sys->ringf_map, &sys->ringf_indices);
587 createVertRingMap(mesh->verts_num, edges, &sys->ringv_map, &sys->ringv_indices);
588
589 for (i = 0; i < sys->tris_num; i++) {
590 sys->tris[i][0] = corner_verts[corner_tris[i][0]];
591 sys->tris[i][1] = corner_verts[corner_tris[i][1]];
592 sys->tris[i][2] = corner_verts[corner_tris[i][2]];
593 }
594 }
595}
596
598 Object *ob,
599 Mesh *mesh,
600 int verts_num)
601{
602 int i;
603 int defgrp_index;
604 int anchors_num = 0;
605 float wpaint;
606 const MDeformVert *dvert = nullptr;
607 const MDeformVert *dv = nullptr;
608 LaplacianSystem *sys = static_cast<LaplacianSystem *>(lmd->cache_system);
609 const bool invert_vgroup = (lmd->flag & MOD_LAPLACIANDEFORM_INVERT_VGROUP) != 0;
610
611 if (sys->verts_num != verts_num) {
613 }
614 if (sys->edges_num != mesh->edges_num) {
616 }
617 if (!STREQ(lmd->anchor_grp_name, sys->anchor_grp_name)) {
619 }
620 MOD_get_vgroup(ob, mesh, lmd->anchor_grp_name, &dvert, &defgrp_index);
621 if (!dvert) {
623 }
624 dv = dvert;
625 for (i = 0; i < verts_num; i++) {
626 wpaint = invert_vgroup ? 1.0f - BKE_defvert_find_weight(dv, defgrp_index) :
627 BKE_defvert_find_weight(dv, defgrp_index);
628 dv++;
629 if (wpaint > 0.0f) {
630 anchors_num++;
631 }
632 }
633 if (sys->anchors_num != anchors_num) {
635 }
636
638}
639
641 LaplacianDeformModifierData *lmd, Object *ob, Mesh *mesh, float (*vertexCos)[3], int verts_num)
642{
643 float (*filevertexCos)[3];
644 int sysdif;
645 LaplacianSystem *sys = nullptr;
646 filevertexCos = nullptr;
647 if (!(lmd->flag & MOD_LAPLACIANDEFORM_BIND)) {
648 if (lmd->cache_system) {
649 sys = static_cast<LaplacianSystem *>(lmd->cache_system);
651 lmd->cache_system = nullptr;
652 }
653 lmd->verts_num = 0;
655 return;
656 }
657 if (lmd->cache_system) {
658 sysdif = isSystemDifferent(lmd, ob, mesh, verts_num);
659 sys = static_cast<LaplacianSystem *>(lmd->cache_system);
660 if (sysdif) {
662 filevertexCos = MEM_new_array_uninitialized<float[3]>(size_t(verts_num), __func__);
663 memcpy(filevertexCos, lmd->vertexco, sizeof(float[3]) * verts_num);
665 lmd->verts_num = 0;
667 lmd->cache_system = nullptr;
668 initSystem(lmd, ob, mesh, filevertexCos, verts_num);
669 sys = static_cast<LaplacianSystem *>(lmd->cache_system); /* may have been reallocated */
670 MEM_SAFE_DELETE(filevertexCos);
671 if (sys) {
672 laplacianDeformPreview(sys, vertexCos);
673 }
674 }
675 else {
676 if (sysdif == LAPDEFORM_SYSTEM_CHANGE_VERTEXES) {
678 ob, &lmd->modifier, "Vertices changed from %d to %d", lmd->verts_num, verts_num);
679 }
680 else if (sysdif == LAPDEFORM_SYSTEM_CHANGE_EDGES) {
682 ob, &lmd->modifier, "Edges changed from %d to %d", sys->edges_num, mesh->edges_num);
683 }
684 else if (sysdif == LAPDEFORM_SYSTEM_CHANGE_NOT_VALID_GROUP) {
686 &lmd->modifier,
687 "Vertex group '%s' is not valid, or maybe empty",
688 sys->anchor_grp_name);
689 }
690 }
691 }
692 else {
693 sys->repeat = lmd->repeat;
694 laplacianDeformPreview(sys, vertexCos);
695 }
696 }
697 else {
698 if (!isValidVertexGroup(lmd, ob, mesh)) {
700 &lmd->modifier,
701 "Vertex group '%s' is not valid, or maybe empty",
702 lmd->anchor_grp_name);
704 }
705 else if (lmd->verts_num > 0 && lmd->verts_num == verts_num) {
706 filevertexCos = MEM_new_array_uninitialized<float[3]>(size_t(verts_num),
707 "TempDeformCoordinates");
708 memcpy(filevertexCos, lmd->vertexco, sizeof(float[3]) * verts_num);
710 lmd->verts_num = 0;
711 initSystem(lmd, ob, mesh, filevertexCos, verts_num);
712 sys = static_cast<LaplacianSystem *>(lmd->cache_system);
713 MEM_SAFE_DELETE(filevertexCos);
714 laplacianDeformPreview(sys, vertexCos);
715 }
716 else {
717 initSystem(lmd, ob, mesh, vertexCos, verts_num);
718 sys = static_cast<LaplacianSystem *>(lmd->cache_system);
719 laplacianDeformPreview(sys, vertexCos);
720 }
721 }
722 if (sys && sys->is_matrix_computed && !sys->has_solution) {
723 BKE_modifier_set_error(ob, &lmd->modifier, "The system did not find a solution");
724 }
725}
726
727static void init_data(ModifierData *md)
728{
729 LaplacianDeformModifierData *lmd = reinterpret_cast<LaplacianDeformModifierData *>(md);
731}
732
733static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
734{
735 const LaplacianDeformModifierData *lmd = reinterpret_cast<const LaplacianDeformModifierData *>(
736 md);
737 LaplacianDeformModifierData *tlmd = reinterpret_cast<LaplacianDeformModifierData *>(target);
738
739 BKE_modifier_copydata_generic(md, target, flag);
740
743 tlmd->cache_system = nullptr;
744}
745
746static bool is_disabled(const Scene * /*scene*/, ModifierData *md, bool /*use_render_params*/)
747{
748 LaplacianDeformModifierData *lmd = reinterpret_cast<LaplacianDeformModifierData *>(md);
749 if (lmd->anchor_grp_name[0]) {
750 return false;
751 }
752 return true;
753}
754
755static void required_data_mask(ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
756{
757 LaplacianDeformModifierData *lmd = reinterpret_cast<LaplacianDeformModifierData *>(md);
758
759 if (lmd->anchor_grp_name[0] != '\0') {
760 r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
761 }
762}
763
765 const ModifierEvalContext *ctx,
766 Mesh *mesh,
767 MutableSpan<float3> positions)
768{
770 ctx->object,
771 mesh,
772 reinterpret_cast<float (*)[3]>(positions.data()),
773 positions.size());
774}
775
776static void free_data(ModifierData *md)
777{
778 LaplacianDeformModifierData *lmd = reinterpret_cast<LaplacianDeformModifierData *>(md);
779 LaplacianSystem *sys = static_cast<LaplacianSystem *>(lmd->cache_system);
780 if (sys) {
782 }
784 lmd->verts_num = 0;
785}
786
787static void panel_draw(const bContext * /*C*/, Panel *panel)
788{
789 ui::Layout &layout = *panel->layout;
790
791 PointerRNA ob_ptr;
793
794 bool is_bind = RNA_boolean_get(ptr, "is_bind");
795 bool has_vertex_group = RNA_string_length(ptr, "vertex_group") != 0;
796
797 layout.use_property_split_set(true);
798
799 layout.prop(ptr, "iterations", UI_ITEM_NONE, std::nullopt, ICON_NONE);
800
801 modifier_vgroup_ui(layout, ptr, &ob_ptr, "vertex_group", "invert_vertex_group", std::nullopt);
802
803 layout.separator();
804
805 ui::Layout &row = layout.row(true);
806 row.enabled_set(has_vertex_group);
807 row.op("OBJECT_OT_laplaciandeform_bind", is_bind ? IFACE_("Unbind") : IFACE_("Bind"), ICON_NONE);
808
809 modifier_error_message_draw(layout, ptr);
810}
811
812static void panel_register(ARegionType *region_type)
813{
815}
816
817static void blend_write(BlendWriter *writer, const ID *id_owner, const ModifierData *md)
818{
819 const LaplacianDeformModifierData *lmd = reinterpret_cast<const LaplacianDeformModifierData *>(
820 md);
821 const bool is_undo = writer->is_undo();
822 const bool without_bind_data = ID_IS_OVERRIDE_LIBRARY(id_owner) && !is_undo &&
824 if (without_bind_data) {
825 /* Modifier coming from linked data cannot be bound from an override, so we can remove all
826 * binding data, can save a significant amount of memory. */
827 BLI_assert(!ID_IS_LINKED(id_owner));
828 writer->write_struct(lmd, [](BlendStructWriter<LaplacianDeformModifierData> &struct_writer) {
829 struct_writer.shallow_data.verts_num = 0;
830 struct_writer.shallow_data.vertexco = nullptr;
831 struct_writer.shallow_data.vertexco_sharing_info = nullptr;
832 });
833 return;
834 }
835
836 if (lmd->vertexco != nullptr) {
837 writer->write_shared(lmd->vertexco,
838 sizeof(float[3]) * lmd->verts_num,
840 [&]() { writer->write_float3_array(lmd->verts_num, lmd->vertexco); });
841 }
842
843 writer->write_struct(lmd);
844}
845
846static void blend_read(BlendDataReader *reader, ModifierData *md)
847{
848 LaplacianDeformModifierData *lmd = reinterpret_cast<LaplacianDeformModifierData *>(md);
849
850 if (lmd->vertexco) {
851 lmd->vertexco_sharing_info = BLO_read_shared(reader, &lmd->vertexco, [&]() {
852 BLO_read_array_and_validate_size(reader, &lmd->vertexco, &lmd->verts_num, 3);
853 return lmd->vertexco ? implicit_sharing::info_for_mem_free(lmd->vertexco) : nullptr;
854 });
855 }
856 lmd->cache_system = nullptr;
857}
858
860 /*idname*/ "LaplacianDeform",
861 /*name*/ N_("LaplacianDeform"),
862 /*struct_name*/ "LaplacianDeformModifierData",
863 /*struct_size*/ sizeof(LaplacianDeformModifierData),
864 /*srna*/ &RNA_LaplacianDeformModifier,
867 /*icon*/ ICON_MOD_MESHDEFORM,
868 /*copy_data*/ copy_data,
869
870 /*deform_verts*/ deform_verts,
871 /*deform_matrices*/ nullptr,
872 /*deform_verts_EM*/ nullptr,
873 /*deform_matrices_EM*/ nullptr,
874 /*modify_mesh*/ nullptr,
875 /*modify_geometry_set*/ nullptr,
876
877 /*init_data*/ init_data,
878 /*required_data_mask*/ required_data_mask,
879 /*free_data*/ free_data,
880 /*is_disabled*/ is_disabled,
881 /*update_depsgraph*/ nullptr,
882 /*depends_on_time*/ nullptr,
883 /*depends_on_normals*/ nullptr,
884 /*foreach_ID_link*/ nullptr,
885 /*foreach_tex_link*/ nullptr,
886 /*free_runtime_data*/ nullptr,
887 /*panel_register*/ panel_register,
888 /*blend_write*/ blend_write,
889 /*blend_read*/ blend_read,
890 /*foreach_cache*/ nullptr,
891 /*foreach_working_space_color*/ nullptr,
892};
893
894} // namespace blender
support for deformation groups and hooks.
#define STACK_PUSH(stack, val)
#define STACK_DECLARE(stack)
#define STACK_SIZE(stack)
#define STACK_INIT(stack, stack_num)
#define IFACE_(msgid)
#define ID_IS_LINKED(_id)
Definition DNA_ID.h:697
#define ID_IS_OVERRIDE_LIBRARY(_id)
Definition DNA_ID.h:736
Read Blender memory allocation and freeing.
#define UI_ITEM_NONE
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
#define UNPACK3(a)
#define ELEM(...)
#define STREQ(a, b)
#define CD_MASK_MDEFORMVERT
constexpr int64_t size() const
Definition BLI_span.hh:499
constexpr T * data() const
Definition BLI_span.hh:545
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
#define FLT_EPSILON
void EIG_linear_solver_variable_set(LinearSolver *solver, int rhs, int index, double value)
void EIG_linear_solver_right_hand_side_add(LinearSolver *solver, int rhs, int index, double value)
LinearSolver * EIG_linear_least_squares_solver_new(int num_rows, int num_columns, int num_right_hand_sides)
void EIG_linear_solver_delete(LinearSolver *solver)
double EIG_linear_solver_variable_get(LinearSolver *solver, int rhs, int index)
void EIG_linear_solver_matrix_add(LinearSolver *solver, int row, int col, double value)
bool EIG_linear_solver_solve(LinearSolver *solver)
ccl_device_inline float beta(const float x, const float y)
Definition math_base.h:708
void copy_shared_pointer(T *src_ptr, const ImplicitSharingInfo *src_sharing_info, T **r_dst_ptr, const ImplicitSharingInfo **r_dst_sharing_info)
void free_shared_data(T **data, const ImplicitSharingInfo **sharing_info)
const ImplicitSharingInfo * info_for_mem_free(T *data)
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)
BLaplacianSystem LaplacianSystem
const ImplicitSharingInfo * BLO_read_shared(BlendDataReader *reader, T **data_ptr, FunctionRef< const ImplicitSharingInfo *()> read_fn)
char * STRNCPY(char(&dst)[N], const char *src)
static void blend_write(BlendWriter *writer, const ID *, const ModifierData *md)
Definition MOD_bevel.cc:454
void BKE_modifier_set_error(const Object *ob, ModifierData *md, const char *format,...) ATTR_PRINTF_FORMAT(3
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 * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
static int isSystemDifferent(LaplacianDeformModifierData *lmd, Object *ob, Mesh *mesh, int verts_num)
@ MOD_LAPLACIANDEFORM_INVERT_VGROUP
static void initLaplacianMatrix(LaplacianSystem *sys)
void MOD_get_vgroup(const Object *ob, const Mesh *mesh, const char *name, const MDeformVert **dvert, int *defgrp_index)
Definition MOD_util.cc:158
@ eModifierType_LaplacianDeform
static void init_data(ModifierData *md)
static bool isValidVertexGroup(LaplacianDeformModifierData *lmd, Object *ob, Mesh *mesh)
float normal_tri_v3(float n[3], const float v1[3], const float v2[3], const float v3[3])
Definition math_geom.cc:45
static void initSystem(LaplacianDeformModifierData *lmd, Object *ob, Mesh *mesh, float(*vertexCos)[3], int verts_num)
static void rotateDifferentialCoordinates(LaplacianSystem *sys)
static void required_data_mask(ModifierData *, CustomData_MeshMasks *r_cddata_masks)
ModifierTypeInfo modifierType_LaplacianDeform
MINLINE void sub_v3_v3(float r[3], const float a[3])
static LaplacianSystem * initLaplacianSystem(int verts_num, int edges_num, int tris_num, int anchors_num, const char defgrpName[64], int iterations)
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
float BKE_defvert_find_weight(const MDeformVert *dvert, int defgroup)
Definition deform.cc:779
@ LAPDEFORM_SYSTEM_CHANGE_VERTEXES
@ LAPDEFORM_SYSTEM_CHANGE_NOT_VALID_GROUP
@ LAPDEFORM_SYSTEM_ONLY_CHANGE_GROUP
@ LAPDEFORM_SYSTEM_ONLY_CHANGE_ANCHORS
@ LAPDEFORM_SYSTEM_IS_DIFFERENT
@ LAPDEFORM_SYSTEM_ONLY_CHANGE_MESH
@ LAPDEFORM_SYSTEM_CHANGE_EDGES
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)
VecBase< int32_t, 3 > int3
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
static void free_data(ModifierData *md)
static void deleteLaplacianSystem(LaplacianSystem *sys)
static void panel_register(ARegionType *region_type)
static void createFaceRingMap(const int mvert_tot, Span< int3 > corner_tris, Span< int > corner_verts, MeshElemMap **r_map, int **r_indices)
static void LaplacianDeformModifier_do(LaplacianDeformModifierData *lmd, Object *ob, Mesh *mesh, float(*vertexCos)[3], int verts_num)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
MINLINE void zero_v3(float r[3])
@ eModifierTypeFlag_SupportsEditmode
@ eModifierTypeFlag_AcceptsMesh
int RNA_string_length(PointerRNA *ptr, const char *name)
static void blend_read(BlendDataReader *, ModifierData *md)
MINLINE void mul_v3_v3fl(float r[3], const float a[3], float f)
MINLINE float normalize_v3(float n[3])
MINLINE void add_v3_v3(float r[3], const float a[3])
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
float cotangent_tri_weight_v3(const float v1[3], const float v2[3], const float v3[3])
Definition math_geom.cc:202
static void computeImplictRotations(LaplacianSystem *sys)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
static void laplacianDeformPreview(LaplacianSystem *sys, float(*vertexCos)[3])
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
MINLINE float len_squared_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
@ eModifierFlag_OverrideLibrary_Local
static void panel_draw(const bContext *, Panel *panel)
static void deform_verts(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh, MutableSpan< float3 > positions)
static bool is_disabled(const Scene *, ModifierData *md, bool)
static void createVertRingMap(const int mvert_tot, const Span< int2 > edges, MeshElemMap **r_map, int **r_indices)
MINLINE float dot_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
static LaplacianSystem * newLaplacianSystem()
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
#define fabsf
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
void write_shared(const void *data, size_t approximate_size_in_bytes, const ImplicitSharingInfo *sharing_info, FunctionRef< void()> write_fn)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
bool is_undo() const
const ImplicitSharingInfoHandle * vertexco_sharing_info
ui::Layout * layout
void enabled_set(bool enabled)
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 separator(float factor=1.0f, LayoutSeparatorType type=LayoutSeparatorType::Auto)
Layout & row(bool align)
#define N_(msgid)