Blender V5.3
MOD_solidify_extrude.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <algorithm>
10
11#include "BLI_math_vector_c.hh"
12#include "BLI_utildefines.hh"
13
14#include "BLI_bitmap.hh"
15#include "BLI_math_geom_c.hh"
17
18#include "DNA_mesh_types.h"
19#include "DNA_meshdata_types.h"
20#include "DNA_object_types.h"
21
22#include "MEM_guardedalloc.h"
23
24#include "BKE_attribute.hh"
26#include "BKE_customdata.hh"
27#include "BKE_deform.hh"
28#include "BKE_mesh.hh"
29
30#include "MOD_solidify_util.hh" /* own include */
31#include "MOD_util.hh"
32
33namespace blender {
34
35/* -------------------------------------------------------------------- */
41
42/* skip shell thickness for non-manifold edges, see #35710. */
43#define USE_NONMANIFOLD_WORKAROUND
44
46 int p1; /* init as -1 */
47 int p2;
48};
49
51{
52 return !((edge_ref->p1 == 0) && (edge_ref->p2 == 0));
53}
54
61 const Span<float3> face_normals,
62 float (*r_vert_nors)[3],
64 BLI_bitmap *edge_tmp_tag
65#endif
66)
67{
68 const int verts_num = mesh->verts_num;
69 const Span<int2> edges = mesh->edges();
70 const OffsetIndices faces = mesh->faces();
71 const Span<int> corner_edges = mesh->corner_edges();
72
73 {
74 EdgeFaceRef *edge_ref_array = MEM_new_array_zeroed<EdgeFaceRef>(edges.size(), __func__);
75 EdgeFaceRef *edge_ref;
76 float edge_normal[3];
77
78 /* Add an edge reference if it's not there, pointing back to the face index. */
79 for (const int i : faces.index_range()) {
80 for (const int edge_i : corner_edges.slice(faces[i])) {
81 /* --- add edge ref to face --- */
82 edge_ref = &edge_ref_array[edge_i];
83 if (!edgeref_is_init(edge_ref)) {
84 edge_ref->p1 = i;
85 edge_ref->p2 = -1;
86 }
87 else if ((edge_ref->p1 != -1) && (edge_ref->p2 == -1)) {
88 edge_ref->p2 = i;
89 }
90 else {
91 /* 3+ faces using an edge, we can't handle this usefully */
92 edge_ref->p1 = edge_ref->p2 = -1;
93#ifdef USE_NONMANIFOLD_WORKAROUND
94 BLI_BITMAP_ENABLE(edge_tmp_tag, edge_i);
95#endif
96 }
97 /* --- done --- */
98 }
99 }
100
101 int i;
102 const int2 *edge;
103 for (i = 0, edge = edges.data(), edge_ref = edge_ref_array; i < edges.size();
104 i++, edge++, edge_ref++)
105 {
106 /* Get the edge vert indices, and edge value (the face indices that use it) */
107
108 if (edgeref_is_init(edge_ref) && (edge_ref->p1 != -1)) {
109 if (edge_ref->p2 != -1) {
110 /* We have 2 faces using this edge, calculate the edges normal
111 * using the angle between the 2 faces as a weighting */
112#if 0
113 add_v3_v3v3(edge_normal, face_nors[edge_ref->f1], face_nors[edge_ref->f2]);
115 edge_normal,
116 angle_normalized_v3v3(face_nors[edge_ref->f1], face_nors[edge_ref->f2]));
117#else
119 edge_normal, face_normals[edge_ref->p1], face_normals[edge_ref->p2]);
120#endif
121 }
122 else {
123 /* only one face attached to that edge */
124 /* an edge without another attached- the weight on this is undefined */
125 copy_v3_v3(edge_normal, face_normals[edge_ref->p1]);
126 }
127 add_v3_v3(r_vert_nors[(*edge)[0]], edge_normal);
128 add_v3_v3(r_vert_nors[(*edge)[1]], edge_normal);
129 }
130 }
131 MEM_delete(edge_ref_array);
132 }
133
134 /* normalize vertex normals and assign */
135 const Span<float3> vert_normals = mesh->vert_normals_true();
136 for (int i = 0; i < verts_num; i++) {
137 if (normalize_v3(r_vert_nors[i]) == 0.0f) {
138 copy_v3_v3(r_vert_nors[i], vert_normals[i]);
139 }
140 }
141}
142
144
145/* -------------------------------------------------------------------- */
148
149/* NOLINTNEXTLINE: readability-function-size */
151{
152 Mesh *result;
153 const SolidifyModifierData *smd = reinterpret_cast<SolidifyModifierData *>(md);
154
155 const uint verts_num = uint(mesh->verts_num);
156 const uint edges_num = uint(mesh->edges_num);
157 const uint faces_num = uint(mesh->faces_num);
158 const uint loops_num = uint(mesh->corners_num);
159 uint newLoops = 0, newPolys = 0, newEdges = 0, newVerts = 0, rimVerts = 0;
160
161 /* Only use material offsets if we have 2 or more materials. */
162 const short mat_nr_max = ctx->object->totcol > 1 ? ctx->object->totcol - 1 : 0;
163 const short mat_ofs = mat_nr_max ? smd->mat_ofs : 0;
164 const short mat_ofs_rim = mat_nr_max ? smd->mat_ofs_rim : 0;
165
166 /* use for edges */
167 /* Over-allocate new_vert_arr, old_vert_arr. */
168 uint *new_vert_arr = nullptr;
169 STACK_DECLARE(new_vert_arr);
170
171 uint *new_edge_arr = nullptr;
172 STACK_DECLARE(new_edge_arr);
173
174 uint *old_vert_arr = MEM_new_array_zeroed<uint>(verts_num, "old_vert_arr in solidify");
175
176 uint *edge_users = nullptr;
177 int *edge_order = nullptr;
178
179 float (*vert_nors)[3] = nullptr;
180 Span<float3> face_normals;
181
182 const bool need_face_normals = (smd->flag & MOD_SOLIDIFY_NORMAL_CALC) ||
183 (smd->flag & MOD_SOLIDIFY_EVEN) ||
185 (smd->bevel_convex != 0);
186
187 const float ofs_orig = -(((-smd->offset_fac + 1.0f) * 0.5f) * smd->offset);
188 const float ofs_new = smd->offset + ofs_orig;
189 const float offset_fac_vg = smd->offset_fac_vg;
190 const float offset_fac_vg_inv = 1.0f - smd->offset_fac_vg;
191 const float bevel_convex = smd->bevel_convex;
192 const bool do_flip = (smd->flag & MOD_SOLIDIFY_FLIP) != 0;
193 const bool do_clamp = (smd->offset_clamp != 0.0f);
194 const bool do_angle_clamp = do_clamp && (smd->flag & MOD_SOLIDIFY_OFFSET_ANGLE_CLAMP) != 0;
195 const bool do_bevel_convex = bevel_convex != 0.0f;
196 const bool do_rim = (smd->flag & MOD_SOLIDIFY_RIM) != 0;
197 const bool do_shell = !(do_rim && (smd->flag & MOD_SOLIDIFY_NOSHELL) != 0);
198
199 /* weights */
200 const MDeformVert *dvert;
201 const bool defgrp_invert = (smd->flag & MOD_SOLIDIFY_VGROUP_INV) != 0;
202 int defgrp_index;
203 const int shell_defgrp_index = BKE_id_defgroup_name_index(&mesh->id, smd->shell_defgrp_name);
204 const int rim_defgrp_index = BKE_id_defgroup_name_index(&mesh->id, smd->rim_defgrp_name);
205
206 /* array size is doubled in case of using a shell */
207 const uint stride = do_shell ? 2 : 1;
208
209 const Span<float3> vert_normals = mesh->vert_normals_true();
210
211 MOD_get_vgroup(ctx->object, mesh, smd->defgrp_name, &dvert, &defgrp_index);
212
213 const Span<float3> orig_vert_positions = mesh->vert_positions();
214 const Span<int2> orig_edges = mesh->edges();
215 const OffsetIndices orig_faces = mesh->faces();
216 const Span<int> orig_corner_verts = mesh->corner_verts();
217 const Span<int> orig_corner_edges = mesh->corner_edges();
218 const bke::AttributeAccessor orig_attributes = mesh->attributes();
219
220 if (need_face_normals) {
221 /* calculate only face normals */
222 face_normals = mesh->face_normals_true();
223 }
224
225 STACK_INIT(new_vert_arr, verts_num * 2);
226 STACK_INIT(new_edge_arr, edges_num * 2);
227
228 if (do_rim) {
229 BLI_bitmap *orig_mvert_tag = BLI_BITMAP_NEW(verts_num, __func__);
230 uint eidx;
231 uint i;
232
233#define INVALID_UNUSED uint(-1)
234#define INVALID_PAIR uint(-2)
235
236 new_vert_arr = MEM_new_array_uninitialized<uint>(2 * verts_num, __func__);
237 new_edge_arr = MEM_new_array_uninitialized<uint>(((edges_num * 2) + verts_num), __func__);
238
239 edge_users = MEM_new_array_uninitialized<uint>(edges_num, __func__);
240 edge_order = MEM_new_array_uninitialized<int>(edges_num, __func__);
241
242 /* save doing 2 loops here... */
243#if 0
244 std::fill_n(edge_users, edges_num, INVALID_UNUSED);
245#endif
246
247 for (eidx = 0; eidx < edges_num; eidx++) {
248 edge_users[eidx] = INVALID_UNUSED;
249 }
250
251 for (const int64_t i : orig_faces.index_range()) {
252 const IndexRange face = orig_faces[i];
253 int j;
254
255 int corner_i_prev = face.last();
256
257 for (j = 0; j < face.size(); j++) {
258 const int corner_i = face[j];
259 const int vert_i = orig_corner_verts[corner_i];
260 const int prev_vert_i = orig_corner_verts[corner_i_prev];
261 /* add edge user */
262 eidx = int(orig_corner_edges[corner_i_prev]);
263 if (edge_users[eidx] == INVALID_UNUSED) {
264 const int2 &edge = orig_edges[eidx];
265 BLI_assert(ELEM(prev_vert_i, edge[0], edge[1]) && ELEM(vert_i, edge[0], edge[1]));
266 edge_users[eidx] = (prev_vert_i > vert_i) == (edge[0] < edge[1]) ? uint(i) :
267 (uint(i) + faces_num);
268 edge_order[eidx] = j;
269 }
270 else {
271 edge_users[eidx] = INVALID_PAIR;
272 }
273 corner_i_prev = corner_i;
274 }
275 }
276
277 for (eidx = 0; eidx < edges_num; eidx++) {
278 if (!ELEM(edge_users[eidx], INVALID_UNUSED, INVALID_PAIR)) {
279 BLI_BITMAP_ENABLE(orig_mvert_tag, orig_edges[eidx][0]);
280 BLI_BITMAP_ENABLE(orig_mvert_tag, orig_edges[eidx][1]);
281 STACK_PUSH(new_edge_arr, eidx);
282 newPolys++;
283 newLoops += 4;
284 }
285 }
286
287 for (i = 0; i < verts_num; i++) {
288 if (BLI_BITMAP_TEST(orig_mvert_tag, i)) {
289 old_vert_arr[i] = STACK_SIZE(new_vert_arr);
290 STACK_PUSH(new_vert_arr, i);
291 rimVerts++;
292 }
293 else {
294 old_vert_arr[i] = INVALID_UNUSED;
295 }
296 }
297
298 MEM_delete(orig_mvert_tag);
299 }
300
301 if (do_shell == false) {
302 /* only add rim vertices */
303 newVerts = rimVerts;
304 /* each extruded face needs an opposite edge */
305 newEdges = newPolys;
306 }
307 else {
308 /* (stride == 2) in this case, so no need to add newVerts/newEdges */
309 BLI_assert(newVerts == 0);
310 BLI_assert(newEdges == 0);
311 }
312
313#ifdef USE_NONMANIFOLD_WORKAROUND
314 BLI_bitmap *edge_tmp_tag = BLI_BITMAP_NEW(mesh->edges_num, __func__);
315#endif
316
317 if (smd->flag & MOD_SOLIDIFY_NORMAL_CALC) {
318 vert_nors = MEM_new_array_zeroed<float[3]>(verts_num, __func__);
320 face_normals,
321 vert_nors
323 ,
324 edge_tmp_tag
325#endif
326 );
327 }
328
330 int((verts_num * stride) + newVerts),
331 int((edges_num * stride) + newEdges + rimVerts),
332 int((faces_num * stride) + newPolys),
333 int((loops_num * stride) + newLoops));
334
335 MutableSpan<float3> vert_positions = result->vert_positions_for_write();
336 MutableSpan<int2> edges = result->edges_for_write();
337 MutableSpan<int> face_offsets = result->face_offsets_for_write();
338 MutableSpan<int> corner_verts = result->corner_verts_for_write();
339 MutableSpan<int> corner_edges = result->corner_edges_for_write();
340 bke::MutableAttributeAccessor result_attributes = result->attributes_for_write();
341
346
347 if (do_shell) {
348 vert_interp.copy(0, 0, int(verts_num));
349 vert_interp.copy(0, int(verts_num), int(verts_num));
350
351 edge_interp.copy(0, 0, int(edges_num));
352 edge_interp.copy(0, int(edges_num), int(edges_num));
353
354 corner_interp.copy(0, 0, int(loops_num));
355 /* DO NOT copy here the 'copied' part of loop data, we want to reverse loops
356 * (so that winding of copied face get reversed, so that normals get reversed
357 * and point in expected direction...).
358 * If we also copy data here, then this data get overwritten
359 * (and allocated memory becomes a memory leak). */
360
361 face_interp.copy(0, 0, int(faces_num));
362 face_interp.copy(0, int(faces_num), int(faces_num));
363 face_offsets.take_front(faces_num).copy_from(mesh->face_offsets().drop_back(1));
364 for (const int i : orig_faces.index_range()) {
365 face_offsets[faces_num + i] = orig_faces[i].start() + mesh->corners_num;
366 }
367 }
368 else {
369 int i, j;
370 vert_interp.copy(0, 0, int(verts_num));
371 for (i = 0, j = int(verts_num); i < verts_num; i++) {
372 if (old_vert_arr[i] != INVALID_UNUSED) {
373 vert_interp.copy(i, j, 1);
374 j++;
375 }
376 }
377
378 edge_interp.copy(0, 0, int(edges_num));
379
380 for (i = 0, j = int(edges_num); i < edges_num; i++) {
381 if (!ELEM(edge_users[i], INVALID_UNUSED, INVALID_PAIR)) {
382 int2 *ed_src, *ed_dst;
383 edge_interp.copy(i, j, 1);
384
385 ed_src = &edges[i];
386 ed_dst = &edges[j];
387 (*ed_dst)[0] = old_vert_arr[(*ed_src)[0]] + verts_num;
388 (*ed_dst)[1] = old_vert_arr[(*ed_src)[1]] + verts_num;
389 j++;
390 }
391 }
392
393 /* will be created later */
394 corner_interp.copy(0, 0, int(loops_num));
395 face_interp.copy(0, 0, int(faces_num));
396 face_offsets.take_front(faces_num).copy_from(mesh->face_offsets().drop_back(1));
397 }
398
399 const VArraySpan orig_vert_bweight = *orig_attributes.lookup<float>("bevel_weight_vert",
401 bke::SpanAttributeWriter<float> result_edge_bweight;
402 if (orig_attributes.contains("bevel_weight_edge") ||
403 (do_bevel_convex || !orig_vert_bweight.is_empty()))
404 {
405 result_edge_bweight = result_attributes.lookup_or_add_for_write_span<float>(
406 "bevel_weight_edge", bke::AttrDomain::Edge);
407 }
408
409 /* Initializes: (`i_end`, `do_shell_align`, `vert_index`). */
410#define INIT_VERT_ARRAY_OFFSETS(test) \
411 if (((ofs_new >= ofs_orig) == do_flip) == test) { \
412 i_end = verts_num; \
413 do_shell_align = true; \
414 vert_index = 0; \
415 } \
416 else { \
417 if (do_shell) { \
418 i_end = verts_num; \
419 do_shell_align = true; \
420 } \
421 else { \
422 i_end = newVerts; \
423 do_shell_align = false; \
424 } \
425 vert_index = verts_num; \
426 } \
427 (void)0
428
429 bke::SpanAttributeWriter dst_material_index =
430 result_attributes.lookup_or_add_for_write_span<int>("material_index", bke::AttrDomain::Face);
431
432 /* flip normals */
433
434 if (do_shell) {
435 for (const int64_t i : IndexRange(mesh->faces_num)) {
436 const IndexRange face = orig_faces[i];
437 const int loop_end = face.size() - 1;
438 int e;
439 int j;
440
441 /* reverses the loop direction (corner verts as well as custom-data)
442 * Corner edges also need to be corrected too, done in a separate loop below. */
443 const int corner_2 = face.start() + mesh->corners_num;
444#if 0
445 for (j = 0; j < face.size(); j++) {
446 corner_interp.copy(face.start() + j, face.start() + (loop_end - j) + mesh->corners_num, 1);
447 }
448#else
449 /* slightly more involved, keep the first vertex the same for the copy,
450 * ensures the diagonals in the new face match the original. */
451 j = 0;
452 for (int j_prev = loop_end; j < face.size(); j_prev = j++) {
453 corner_interp.copy(
454 face.start() + j, face.start() + (loop_end - j_prev) + mesh->corners_num, 1);
455 }
456#endif
457
458 if (mat_ofs) {
459 dst_material_index.span[faces_num + i] += mat_ofs;
460 CLAMP(dst_material_index.span[faces_num + i], 0, mat_nr_max);
461 }
462
463 e = corner_edges[corner_2 + 0];
464 for (j = 0; j < loop_end; j++) {
465 corner_edges[corner_2 + j] = corner_edges[corner_2 + j + 1];
466 }
467 corner_edges[corner_2 + loop_end] = e;
468
469 for (j = 0; j < face.size(); j++) {
470 corner_verts[corner_2 + j] += verts_num;
471 corner_edges[corner_2 + j] += edges_num;
472 }
473 }
474
475 for (int2 &edge : edges.slice(edges_num, edges_num)) {
476 edge += verts_num;
477 }
478 }
479
480 /* NOTE: copied vertex layers don't have flipped normals yet. do this after applying offset. */
481 if ((smd->flag & MOD_SOLIDIFY_EVEN) == 0) {
482 /* no even thickness, very simple */
483 float ofs_new_vgroup;
484
485 /* for clamping */
486 float *vert_lens = nullptr;
487 float *vert_angs = nullptr;
488 const float offset = fabsf(smd->offset) * smd->offset_clamp;
489 const float offset_sq = offset * offset;
490
491 /* for bevel weight */
492 float *edge_angs = nullptr;
493
494 if (do_clamp) {
495 vert_lens = MEM_new_array_uninitialized<float>(verts_num, "vert_lens");
496 std::fill_n(vert_lens, int(verts_num), FLT_MAX);
497 for (uint i = 0; i < edges_num; i++) {
498 const float ed_len_sq = len_squared_v3v3(vert_positions[edges[i][0]],
499 vert_positions[edges[i][1]]);
500 vert_lens[edges[i][0]] = min_ff(vert_lens[edges[i][0]], ed_len_sq);
501 vert_lens[edges[i][1]] = min_ff(vert_lens[edges[i][1]], ed_len_sq);
502 }
503 }
504
505 if (do_angle_clamp || do_bevel_convex) {
506 uint eidx;
507 if (do_angle_clamp) {
508 vert_angs = MEM_new_array_uninitialized<float>(verts_num, "vert_angs");
509 std::fill_n(vert_angs, int(verts_num), 0.5f * M_PI);
510 }
511 if (do_bevel_convex) {
512 edge_angs = MEM_new_array_uninitialized<float>(edges_num, "edge_angs");
513 if (!do_rim) {
514 edge_users = MEM_new_array_uninitialized<uint>(edges_num, "solid_mod edges");
515 }
516 }
517 uint(*edge_user_pairs)[2] = MEM_new_array_uninitialized<uint[2]>(edges_num,
518 "edge_user_pairs");
519 for (eidx = 0; eidx < edges_num; eidx++) {
520 edge_user_pairs[eidx][0] = INVALID_UNUSED;
521 edge_user_pairs[eidx][1] = INVALID_UNUSED;
522 }
523 for (const int64_t i : orig_faces.index_range()) {
524 const IndexRange face = orig_faces[i];
525 int prev_corner_i = face.last();
526 for (const int corner_i : face) {
527 const int vert_i = orig_corner_verts[corner_i];
528 const int prev_vert_i = orig_corner_verts[prev_corner_i];
529 /* add edge user */
530 eidx = orig_corner_edges[prev_corner_i];
531 const int2 &ed = orig_edges[eidx];
532 BLI_assert(ELEM(prev_vert_i, ed[0], ed[1]) && ELEM(vert_i, ed[0], ed[1]));
533 char flip = char((prev_vert_i > vert_i) == (ed[0] < ed[1]));
534 if (edge_user_pairs[eidx][flip] == INVALID_UNUSED) {
535 edge_user_pairs[eidx][flip] = uint(i);
536 }
537 else {
538 edge_user_pairs[eidx][0] = INVALID_PAIR;
539 edge_user_pairs[eidx][1] = INVALID_PAIR;
540 }
541 prev_corner_i = corner_i;
542 }
543 }
544 float e[3];
545 for (uint i = 0; i < edges_num; i++) {
546 const int2 &edge = orig_edges[i];
547 if (!ELEM(edge_user_pairs[i][0], INVALID_UNUSED, INVALID_PAIR) &&
548 !ELEM(edge_user_pairs[i][1], INVALID_UNUSED, INVALID_PAIR))
549 {
550 const float *n0 = face_normals[edge_user_pairs[i][0]];
551 const float *n1 = face_normals[edge_user_pairs[i][1]];
552 sub_v3_v3v3(e, orig_vert_positions[edge[0]], orig_vert_positions[edge[1]]);
554 const float angle = angle_signed_on_axis_v3v3_v3(n0, n1, e);
555 if (do_angle_clamp) {
556 vert_angs[edge[0]] = max_ff(vert_angs[edge[0]], angle);
557 vert_angs[edge[1]] = max_ff(vert_angs[edge[1]], angle);
558 }
559 if (do_bevel_convex) {
560 edge_angs[i] = angle;
561 if (!do_rim) {
562 edge_users[i] = INVALID_PAIR;
563 }
564 }
565 }
566 }
567 MEM_delete(edge_user_pairs);
568 }
569
570 if (ofs_new != 0.0f) {
571 uint i_orig, i_end;
572 bool do_shell_align;
573
574 ofs_new_vgroup = ofs_new;
575
576 uint vert_index;
578
579 for (i_orig = 0; i_orig < i_end; i_orig++, vert_index++) {
580 const uint i = do_shell_align ? i_orig : new_vert_arr[i_orig];
581 if (dvert) {
582 const MDeformVert *dv = &dvert[i];
583 if (defgrp_invert) {
584 ofs_new_vgroup = 1.0f - BKE_defvert_find_weight(dv, defgrp_index);
585 }
586 else {
587 ofs_new_vgroup = BKE_defvert_find_weight(dv, defgrp_index);
588 }
589 ofs_new_vgroup = (offset_fac_vg + (ofs_new_vgroup * offset_fac_vg_inv)) * ofs_new;
590 }
591 if (do_clamp && offset > FLT_EPSILON) {
592 /* always reset because we may have set before */
593 if (dvert == nullptr) {
594 ofs_new_vgroup = ofs_new;
595 }
596 if (do_angle_clamp) {
597 float cos_ang = cosf(((2 * M_PI) - vert_angs[i]) * 0.5f);
598 if (cos_ang > 0) {
599 float max_off = sqrtf(vert_lens[i]) * 0.5f / cos_ang;
600 if (max_off < offset * 0.5f) {
601 ofs_new_vgroup *= max_off / offset * 2;
602 }
603 }
604 }
605 else {
606 if (vert_lens[i] < offset_sq) {
607 float scalar = sqrtf(vert_lens[i]) / offset;
608 ofs_new_vgroup *= scalar;
609 }
610 }
611 }
612 if (vert_nors) {
613 madd_v3_v3fl(vert_positions[vert_index], vert_nors[i], ofs_new_vgroup);
614 }
615 else {
616 madd_v3_v3fl(vert_positions[vert_index], vert_normals[i], ofs_new_vgroup);
617 }
618 }
619 }
620
621 if (ofs_orig != 0.0f) {
622 uint i_orig, i_end;
623 bool do_shell_align;
624
625 ofs_new_vgroup = ofs_orig;
626
627 /* as above but swapped */
628 uint vert_index;
630
631 for (i_orig = 0; i_orig < i_end; i_orig++, vert_index++) {
632 const uint i = do_shell_align ? i_orig : new_vert_arr[i_orig];
633 if (dvert) {
634 const MDeformVert *dv = &dvert[i];
635 if (defgrp_invert) {
636 ofs_new_vgroup = 1.0f - BKE_defvert_find_weight(dv, defgrp_index);
637 }
638 else {
639 ofs_new_vgroup = BKE_defvert_find_weight(dv, defgrp_index);
640 }
641 ofs_new_vgroup = (offset_fac_vg + (ofs_new_vgroup * offset_fac_vg_inv)) * ofs_orig;
642 }
643 if (do_clamp && offset > FLT_EPSILON) {
644 /* always reset because we may have set before */
645 if (dvert == nullptr) {
646 ofs_new_vgroup = ofs_orig;
647 }
648 if (do_angle_clamp) {
649 float cos_ang = cosf(vert_angs[i_orig] * 0.5f);
650 if (cos_ang > 0) {
651 float max_off = sqrtf(vert_lens[i]) * 0.5f / cos_ang;
652 if (max_off < offset * 0.5f) {
653 ofs_new_vgroup *= max_off / offset * 2;
654 }
655 }
656 }
657 else {
658 if (vert_lens[i] < offset_sq) {
659 float scalar = sqrtf(vert_lens[i]) / offset;
660 ofs_new_vgroup *= scalar;
661 }
662 }
663 }
664 if (vert_nors) {
665 madd_v3_v3fl(vert_positions[vert_index], vert_nors[i], ofs_new_vgroup);
666 }
667 else {
668 madd_v3_v3fl(vert_positions[vert_index], vert_normals[i], ofs_new_vgroup);
669 }
670 }
671 }
672
673 if (do_bevel_convex) {
674 for (uint i = 0; i < edges_num; i++) {
675 if (edge_users[i] == INVALID_PAIR) {
676 float angle = edge_angs[i];
677 result_edge_bweight.span[i] = clamp_f(
678 result_edge_bweight.span[i] + (angle < M_PI ? clamp_f(bevel_convex, 0.0f, 1.0f) :
679 clamp_f(bevel_convex, -1.0f, 0.0f)),
680 0.0f,
681 1.0f);
682 if (do_shell) {
683 result_edge_bweight.span[i + edges_num] = clamp_f(
684 result_edge_bweight.span[i + edges_num] + (angle > M_PI ?
685 clamp_f(bevel_convex, 0.0f, 1.0f) :
686 clamp_f(bevel_convex, -1.0f, 0.0f)),
687 0,
688 1.0f);
689 }
690 }
691 }
692 if (!do_rim) {
693 MEM_delete(edge_users);
694 }
695 MEM_delete(edge_angs);
696 }
697
698 if (do_clamp) {
699 MEM_delete(vert_lens);
700 if (do_angle_clamp) {
701 MEM_delete(vert_angs);
702 }
703 }
704 }
705 else {
706#ifdef USE_NONMANIFOLD_WORKAROUND
707 const bool check_non_manifold = (smd->flag & MOD_SOLIDIFY_NORMAL_CALC) != 0;
708#endif
709 float *vert_angles = MEM_new_array_zeroed<float>(2 * verts_num, "mod_solid_pair"); /* 2 in 1 */
710 float *vert_accum = vert_angles + verts_num;
711 uint vidx;
712 uint i;
713
714 if (vert_nors == nullptr) {
715 vert_nors = MEM_new_array_uninitialized<float[3]>(verts_num, "mod_solid_vno");
716 for (i = 0; i < verts_num; i++) {
717 copy_v3_v3(vert_nors[i], vert_normals[i]);
718 }
719 }
720
721 for (const int64_t i : IndexRange(faces_num)) {
722 const IndexRange face = orig_faces[i];
723 /* #bke::mesh::face_angles_calc logic is inlined here */
724 float nor_prev[3];
725 float nor_next[3];
726
727 int i_curr = face.size() - 1;
728 int i_next = 0;
729
730 const int *face_verts = &corner_verts[face.start()];
731 const int *face_edges = &corner_edges[face.start()];
732
734 nor_prev, vert_positions[face_verts[i_curr - 1]], vert_positions[face_verts[i_curr]]);
735 normalize_v3(nor_prev);
736
737 while (i_next < face.size()) {
738 float angle;
740 nor_next, vert_positions[face_verts[i_curr]], vert_positions[face_verts[i_next]]);
741 normalize_v3(nor_next);
742 angle = angle_normalized_v3v3(nor_prev, nor_next);
743
744 /* --- not related to angle calc --- */
745 angle = std::max(angle, FLT_EPSILON);
746
747 vidx = face_verts[i_curr];
748 vert_accum[vidx] += angle;
749
750#ifdef USE_NONMANIFOLD_WORKAROUND
751 /* skip 3+ face user edges */
752 if ((check_non_manifold == false) ||
753 LIKELY(!BLI_BITMAP_TEST(edge_tmp_tag, face_edges[i_curr]) &&
754 !BLI_BITMAP_TEST(edge_tmp_tag, face_edges[i_next])))
755 {
756 vert_angles[vidx] += shell_v3v3_normalized_to_dist(vert_nors[vidx], face_normals[i]) *
757 angle;
758 }
759 else {
760 vert_angles[vidx] += angle;
761 }
762#else
763 vert_angles[vidx] += shell_v3v3_normalized_to_dist(vert_nors[vidx], face_normals[i]) *
764 angle;
765#endif
766 /* --- end non-angle-calc section --- */
767
768 /* step */
769 copy_v3_v3(nor_prev, nor_next);
770 i_curr = i_next;
771 i_next++;
772 }
773 }
774
775 /* vertex group support */
776 if (dvert) {
777 const MDeformVert *dv = dvert;
778 float scalar;
779
780 if (defgrp_invert) {
781 for (i = 0; i < verts_num; i++, dv++) {
782 scalar = 1.0f - BKE_defvert_find_weight(dv, defgrp_index);
783 scalar = offset_fac_vg + (scalar * offset_fac_vg_inv);
784 vert_angles[i] *= scalar;
785 }
786 }
787 else {
788 for (i = 0; i < verts_num; i++, dv++) {
789 scalar = BKE_defvert_find_weight(dv, defgrp_index);
790 scalar = offset_fac_vg + (scalar * offset_fac_vg_inv);
791 vert_angles[i] *= scalar;
792 }
793 }
794 }
795
796 /* for angle clamp */
797 float *vert_angs = nullptr;
798 /* for bevel convex */
799 float *edge_angs = nullptr;
800
801 if (do_angle_clamp || do_bevel_convex) {
802 uint eidx;
803 if (do_angle_clamp) {
804 vert_angs = MEM_new_array_uninitialized<float>(verts_num, "vert_angs even");
805 std::fill_n(vert_angs, int(verts_num), 0.5f * M_PI);
806 }
807 if (do_bevel_convex) {
808 edge_angs = MEM_new_array_uninitialized<float>(edges_num, "edge_angs even");
809 if (!do_rim) {
810 edge_users = MEM_new_array_uninitialized<uint>(edges_num, "solid_mod edges");
811 }
812 }
813 uint(*edge_user_pairs)[2] = MEM_new_array_uninitialized<uint[2]>(edges_num,
814 "edge_user_pairs");
815 for (eidx = 0; eidx < edges_num; eidx++) {
816 edge_user_pairs[eidx][0] = INVALID_UNUSED;
817 edge_user_pairs[eidx][1] = INVALID_UNUSED;
818 }
819 for (const int i : orig_faces.index_range()) {
820 const IndexRange face = orig_faces[i];
821 int prev_corner_i = face.start() + face.size() - 1;
822 for (int j = 0; j < face.size(); j++) {
823 const int corner_i = face.start() + j;
824 const int vert_i = orig_corner_verts[corner_i];
825 const int prev_vert_i = orig_corner_verts[prev_corner_i];
826
827 /* add edge user */
828 eidx = orig_corner_edges[prev_corner_i];
829 const int2 &edge = orig_edges[eidx];
830 BLI_assert(ELEM(prev_vert_i, edge[0], edge[1]) && ELEM(vert_i, edge[0], edge[1]));
831 char flip = char((prev_vert_i > vert_i) == (edge[0] < edge[1]));
832 if (edge_user_pairs[eidx][flip] == INVALID_UNUSED) {
833 edge_user_pairs[eidx][flip] = uint(i);
834 }
835 else {
836 edge_user_pairs[eidx][0] = INVALID_PAIR;
837 edge_user_pairs[eidx][1] = INVALID_PAIR;
838 }
839 prev_corner_i = corner_i;
840 }
841 }
842 float e[3];
843 for (i = 0; i < edges_num; i++) {
844 const int2 &edge = orig_edges[i];
845 if (!ELEM(edge_user_pairs[i][0], INVALID_UNUSED, INVALID_PAIR) &&
846 !ELEM(edge_user_pairs[i][1], INVALID_UNUSED, INVALID_PAIR))
847 {
848 const float *n0 = face_normals[edge_user_pairs[i][0]];
849 const float *n1 = face_normals[edge_user_pairs[i][1]];
850 if (do_angle_clamp) {
851 const float angle = M_PI - angle_normalized_v3v3(n0, n1);
852 vert_angs[edge[0]] = max_ff(vert_angs[edge[0]], angle);
853 vert_angs[edge[1]] = max_ff(vert_angs[edge[1]], angle);
854 }
855 if (do_bevel_convex) {
856 sub_v3_v3v3(e, orig_vert_positions[edge[0]], orig_vert_positions[edge[1]]);
858 edge_angs[i] = angle_signed_on_axis_v3v3_v3(n0, n1, e);
859 if (!do_rim) {
860 edge_users[i] = INVALID_PAIR;
861 }
862 }
863 }
864 }
865 MEM_delete(edge_user_pairs);
866 }
867
868 if (do_clamp) {
869 const float clamp_fac = 1 + (do_angle_clamp ? fabsf(smd->offset_fac) : 0);
870 const float offset = fabsf(smd->offset) * smd->offset_clamp * clamp_fac;
871 if (offset > FLT_EPSILON) {
872 float *vert_lens_sq = MEM_new_array_uninitialized<float>(verts_num, "vert_lens_sq");
873 const float offset_sq = offset * offset;
874 std::fill_n(vert_lens_sq, int(verts_num), FLT_MAX);
875 for (i = 0; i < edges_num; i++) {
876 const float ed_len = len_squared_v3v3(vert_positions[edges[i][0]],
877 vert_positions[edges[i][1]]);
878 vert_lens_sq[edges[i][0]] = min_ff(vert_lens_sq[edges[i][0]], ed_len);
879 vert_lens_sq[edges[i][1]] = min_ff(vert_lens_sq[edges[i][1]], ed_len);
880 }
881 if (do_angle_clamp) {
882 for (i = 0; i < verts_num; i++) {
883 float cos_ang = cosf(vert_angs[i] * 0.5f);
884 if (cos_ang > 0) {
885 float max_off = sqrtf(vert_lens_sq[i]) * 0.5f / cos_ang;
886 if (max_off < offset * 0.5f) {
887 vert_angles[i] *= max_off / offset * 2;
888 }
889 }
890 }
891 MEM_delete(vert_angs);
892 }
893 else {
894 for (i = 0; i < verts_num; i++) {
895 if (vert_lens_sq[i] < offset_sq) {
896 float scalar = sqrtf(vert_lens_sq[i]) / offset;
897 vert_angles[i] *= scalar;
898 }
899 }
900 }
901 MEM_delete(vert_lens_sq);
902 }
903 }
904
905 if (do_bevel_convex) {
906 for (i = 0; i < edges_num; i++) {
907 if (edge_users[i] == INVALID_PAIR) {
908 float angle = edge_angs[i];
909 result_edge_bweight.span[i] = clamp_f(
910 result_edge_bweight.span[i] + (angle < M_PI ? clamp_f(bevel_convex, 0.0f, 1.0f) :
911 clamp_f(bevel_convex, -1.0f, 0.0f)),
912 0.0f,
913 1.0f);
914 if (do_shell) {
915 result_edge_bweight.span[i + edges_num] = clamp_f(
916 result_edge_bweight.span[i + edges_num] +
917 (angle > M_PI ? clamp_f(bevel_convex, 0, 1) : clamp_f(bevel_convex, -1, 0)),
918 0.0f,
919 1.0f);
920 }
921 }
922 }
923 if (!do_rim) {
924 MEM_delete(edge_users);
925 }
926 MEM_delete(edge_angs);
927 }
928
929#undef INVALID_UNUSED
930#undef INVALID_PAIR
931
932 if (ofs_new != 0.0f) {
933 uint i_orig, i_end;
934 bool do_shell_align;
935
936 uint vert_index;
938
939 for (i_orig = 0; i_orig < i_end; i_orig++, vert_index++) {
940 const uint i_other = do_shell_align ? i_orig : new_vert_arr[i_orig];
941 if (vert_accum[i_other]) { /* zero if unselected */
942 madd_v3_v3fl(vert_positions[vert_index],
943 vert_nors[i_other],
944 ofs_new * (vert_angles[i_other] / vert_accum[i_other]));
945 }
946 }
947 }
948
949 if (ofs_orig != 0.0f) {
950 uint i_orig, i_end;
951 bool do_shell_align;
952
953 /* same as above but swapped, intentional use of 'ofs_new' */
954 uint vert_index;
956
957 for (i_orig = 0; i_orig < i_end; i_orig++, vert_index++) {
958 const uint i_other = do_shell_align ? i_orig : new_vert_arr[i_orig];
959 if (vert_accum[i_other]) { /* zero if unselected */
960 madd_v3_v3fl(vert_positions[vert_index],
961 vert_nors[i_other],
962 ofs_orig * (vert_angles[i_other] / vert_accum[i_other]));
963 }
964 }
965 }
966
967 MEM_delete(vert_angles);
968 }
969
970#ifdef USE_NONMANIFOLD_WORKAROUND
971 MEM_SAFE_DELETE(edge_tmp_tag);
972#endif
973
974 if (vert_nors) {
975 MEM_delete(vert_nors);
976 }
977
978 /* Add vertex weights for rim and shell vgroups. */
979 if (shell_defgrp_index != -1 || rim_defgrp_index != -1) {
980 MDeformVert *dst_dvert = result->deform_verts_for_write().data();
981
982 /* Ultimate security check. */
983 if (dst_dvert != nullptr) {
984
985 if (rim_defgrp_index != -1) {
986 for (uint i = 0; i < rimVerts; i++) {
987 BKE_defvert_ensure_index(&dst_dvert[new_vert_arr[i]], rim_defgrp_index)->weight = 1.0f;
988 BKE_defvert_ensure_index(&dst_dvert[(do_shell ? new_vert_arr[i] : i) + verts_num],
989 rim_defgrp_index)
990 ->weight = 1.0f;
991 }
992 }
993
994 if (shell_defgrp_index != -1) {
995 for (uint i = verts_num; i < result->verts_num; i++) {
996 BKE_defvert_ensure_index(&dst_dvert[i], shell_defgrp_index)->weight = 1.0f;
997 }
998 }
999 }
1000 }
1001 if (do_rim) {
1002 uint i;
1003
1004 const float crease_rim = smd->crease_rim;
1005 const float crease_outer = smd->crease_outer;
1006 const float crease_inner = smd->crease_inner;
1007
1008 int *origindex_edge;
1009 int *orig_ed;
1010 uint j;
1011
1012 bke::SpanAttributeWriter<float> result_edge_crease;
1013 if (crease_rim || crease_outer || crease_inner) {
1014 result_edge_crease = result_attributes.lookup_or_add_for_write_span<float>(
1015 "crease_edge", bke::AttrDomain::Edge);
1016 }
1017
1018 /* add faces & edges */
1019 origindex_edge = static_cast<int *>(
1020 CustomData_get_layer_for_write(&result->edge_data, CD_ORIGINDEX, result->edges_num));
1021 orig_ed = (origindex_edge) ? &origindex_edge[(edges_num * stride) + newEdges] : nullptr;
1022 /* Start after copied edges. */
1023 int new_edge_index = int(edges_num * stride + newEdges);
1024 for (i = 0; i < rimVerts; i++) {
1025 edges[new_edge_index][0] = new_vert_arr[i];
1026 edges[new_edge_index][1] = (do_shell ? new_vert_arr[i] : i) + verts_num;
1027
1028 if (result_edge_bweight && !orig_vert_bweight.is_empty()) {
1029 result_edge_bweight.span[new_edge_index] = orig_vert_bweight[new_vert_arr[i]];
1030 }
1031
1032 if (orig_ed) {
1033 *orig_ed = ORIGINDEX_NONE;
1034 orig_ed++;
1035 }
1036
1037 if (result_edge_crease && crease_rim) {
1038 result_edge_crease.span[new_edge_index] = crease_rim;
1039 }
1040 new_edge_index++;
1041 }
1042
1043 /* faces */
1044 int new_face_index = int(faces_num * stride);
1045 MutableSpan<int> new_corner_verts = corner_verts.drop_front(loops_num * stride);
1046 MutableSpan<int> new_corner_edges = corner_edges.drop_front(loops_num * stride);
1047 j = 0;
1048 for (i = 0; i < newPolys; i++) {
1049 uint eidx = new_edge_arr[i];
1050 uint pidx = edge_users[eidx];
1051 int k1, k2;
1052 bool flip;
1053
1054 if (pidx >= faces_num) {
1055 pidx -= faces_num;
1056 flip = true;
1057 }
1058 else {
1059 flip = false;
1060 }
1061
1062 const int2 &edge = edges[eidx];
1063
1064 /* copy most of the face settings */
1065 face_interp.copy(int(pidx), int((faces_num * stride) + i), 1);
1066
1067 const int old_face_size = orig_faces[pidx].size();
1068 face_offsets[new_face_index] = int(j + (loops_num * stride));
1069
1070 /* prev loop */
1071 k1 = face_offsets[pidx] + (((edge_order[eidx] - 1) + old_face_size) % old_face_size);
1072
1073 k2 = face_offsets[pidx] + (edge_order[eidx]);
1074
1075 corner_interp.copy(k2, int((loops_num * stride) + j + 0), 1);
1076 corner_interp.copy(k1, int((loops_num * stride) + j + 1), 1);
1077 corner_interp.copy(k1, int((loops_num * stride) + j + 2), 1);
1078 corner_interp.copy(k2, int((loops_num * stride) + j + 3), 1);
1079
1080 if (flip == false) {
1081 new_corner_verts[j] = edge[0];
1082 new_corner_edges[j++] = eidx;
1083
1084 new_corner_verts[j] = edge[1];
1085 new_corner_edges[j++] = (edges_num * stride) + old_vert_arr[edge[1]] + newEdges;
1086
1087 new_corner_verts[j] = (do_shell ? edge[1] : old_vert_arr[edge[1]]) + verts_num;
1088 new_corner_edges[j++] = (do_shell ? eidx : i) + edges_num;
1089
1090 new_corner_verts[j] = (do_shell ? edge[0] : old_vert_arr[edge[0]]) + verts_num;
1091 new_corner_edges[j++] = (edges_num * stride) + old_vert_arr[edge[0]] + newEdges;
1092 }
1093 else {
1094 new_corner_verts[j] = edge[1];
1095 new_corner_edges[j++] = eidx;
1096
1097 new_corner_verts[j] = edge[0];
1098 new_corner_edges[j++] = (edges_num * stride) + old_vert_arr[edge[0]] + newEdges;
1099
1100 new_corner_verts[j] = (do_shell ? edge[0] : old_vert_arr[edge[0]]) + verts_num;
1101 new_corner_edges[j++] = (do_shell ? eidx : i) + edges_num;
1102
1103 new_corner_verts[j] = (do_shell ? edge[1] : old_vert_arr[edge[1]]) + verts_num;
1104 new_corner_edges[j++] = (edges_num * stride) + old_vert_arr[edge[1]] + newEdges;
1105 }
1106
1107 if (origindex_edge) {
1108 origindex_edge[new_corner_edges[j - 3]] = ORIGINDEX_NONE;
1109 origindex_edge[new_corner_edges[j - 1]] = ORIGINDEX_NONE;
1110 }
1111
1112 /* use the next material index if option enabled */
1113 if (mat_ofs_rim) {
1114 dst_material_index.span[new_face_index] += mat_ofs_rim;
1115 CLAMP(dst_material_index.span[new_face_index], 0, mat_nr_max);
1116 }
1117 if (result_edge_crease && crease_outer) {
1118 /* crease += crease_outer; without wrapping */
1119 float *cr = &(result_edge_crease.span[eidx]);
1120 float tcr = *cr + crease_outer;
1121 *cr = tcr > 1.0f ? 1.0f : tcr;
1122 }
1123
1124 if (result_edge_crease && crease_inner) {
1125 /* crease += crease_inner; without wrapping */
1126 float *cr = &(result_edge_crease.span[edges_num + (do_shell ? eidx : i)]);
1127 float tcr = *cr + crease_inner;
1128 *cr = tcr > 1.0f ? 1.0f : tcr;
1129 }
1130
1131 new_face_index++;
1132 }
1133
1134 MEM_delete(new_vert_arr);
1135 MEM_delete(new_edge_arr);
1136
1137 MEM_delete(edge_users);
1138 MEM_delete(edge_order);
1139
1140 result_edge_crease.finish();
1141 }
1142
1143 if (old_vert_arr) {
1144 MEM_delete(old_vert_arr);
1145 }
1146
1147 result_edge_bweight.finish();
1148 dst_material_index.finish();
1149
1150 return result;
1151}
1152
1154
1155} // namespace blender
CustomData interface, see also DNA_customdata_types.h.
#define ORIGINDEX_NONE
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 M_PI
#define STACK_PUSH(stack, val)
#define STACK_DECLARE(stack)
#define STACK_SIZE(stack)
#define STACK_INIT(stack, stack_num)
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define INVALID_UNUSED
#define USE_NONMANIFOLD_WORKAROUND
#define INVALID_PAIR
#define INIT_VERT_ARRAY_OFFSETS(test)
#define CLAMP(a, b, c)
#define BLI_INLINE
#define ELEM(...)
#define LIKELY(x)
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
Definition btVector3.h:356
constexpr int64_t last(const int64_t n=0) const
constexpr int64_t size() const
constexpr IndexRange()=default
constexpr int64_t start() const
constexpr MutableSpan slice(const int64_t start, const int64_t size) const
Definition BLI_span.hh:579
constexpr MutableSpan drop_front(const int64_t n) const
Definition BLI_span.hh:613
constexpr MutableSpan take_front(const int64_t n) const
Definition BLI_span.hh:635
constexpr Span slice(int64_t start, int64_t size) const
Definition BLI_span.hh:141
constexpr const T * data() const
Definition BLI_span.hh:219
constexpr int64_t size() const
Definition BLI_span.hh:256
bool contains(StringRef name) const
GAttributeReader lookup(const StringRef name) const
void copy(int src_index, int dst_index, int count) const
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
constexpr void copy_from(Span< T > values) const
constexpr bool is_empty() const
#define FLT_MAX
#define FLT_EPSILON
BMesh Iterators.
MINLINE float min_ff(float a, float b)
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
void mid_v3_v3v3_angle_weighted(float r[3], const float a[3], const float b[3])
MINLINE float shell_v3v3_normalized_to_dist(const float a[3], const float b[3])
float angle_normalized_v3v3(const float v1[3], const float v2[3]) ATTR_WARN_UNUSED_RESULT
__int64 int64_t
Definition BKE_text.h:90
static void mesh_calc_hq_normal(Mesh *mesh, const Span< float3 > face_normals, float(*r_vert_nors)[3], BLI_bitmap *edge_tmp_tag)
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
MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[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
float angle_signed_on_axis_v3v3_v3(const float v1[3], const float v2[3], const float axis[3]) ATTR_WARN_UNUSED_RESULT
int BKE_id_defgroup_name_index(const ID *id, StringRef name)
Definition deform.cc:557
MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f)
float BKE_defvert_find_weight(const MDeformVert *dvert, int defgroup)
Definition deform.cc:779
Mesh * MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh)
VecBase< int32_t, 2 > int2
MDeformWeight * BKE_defvert_ensure_index(MDeformVert *dv, int defgroup)
Definition deform.cc:830
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])
unsigned int BLI_bitmap
Definition BLI_bitmap.hh:15
MINLINE float max_ff(float a, float b)
MINLINE float normalize_v3_length(float n[3], float unit_length)
Mesh * BKE_mesh_new_nomain_from_template(const Mesh *me_src, int verts_num, int edges_num, int faces_num, int corners_num)
BLI_INLINE bool edgeref_is_init(const EdgeFaceRef *edge_ref)
void * CustomData_get_layer_for_write(CustomData *data, eCustomDataType type, int totelem)
@ MOD_SOLIDIFY_OFFSET_ANGLE_CLAMP
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
MINLINE float clamp_f(float value, float min, float max)
#define fabsf
#define sqrtf
#define cosf
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float