Blender V5.3
MOD_normal_edit.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 <cstring>
10
11#include "MEM_guardedalloc.h"
12
13#include "BLI_utildefines.hh"
14
15#include "BLI_bitmap.hh"
16#include "BLI_math_matrix_c.hh"
17#include "BLI_math_vector.hh"
18#include "BLI_math_vector_c.hh"
19
20#include "BLT_translation.hh"
21
22#include "DNA_mesh_types.h"
23#include "DNA_object_types.h"
24#include "DNA_screen_types.h"
25
26#include "BKE_attribute.hh"
27#include "BKE_deform.hh"
28#include "BKE_lib_id.hh"
29#include "BKE_lib_query.hh"
30#include "BKE_mesh.hh"
31
33#include "UI_resources.hh"
34
35#include "RNA_access.hh"
36#include "RNA_prototypes.hh"
37
38#include "MOD_ui_common.hh"
39#include "MOD_util.hh"
40
41namespace blender {
42
44 Object *ob,
45 Object *ob_center,
46 const float offset[3],
47 const int verts_num,
48 float (*r_cos)[3],
49 float3 *r_size)
50{
51 float min_co[3], max_co[3];
52 float diff[3];
53 bool do_diff = false;
54
55 INIT_MINMAX(min_co, max_co);
56
57 const Span<float3> positions = mesh->vert_positions();
58 for (int i = 0; i < mesh->verts_num; i++) {
59 copy_v3_v3(r_cos[i], positions[i]);
60 if (r_size != nullptr && ob_center == nullptr) {
61 minmax_v3v3_v3(min_co, max_co, r_cos[i]);
62 }
63 }
64
65 /* Get size (i.e. deformation of the spheroid generating normals),
66 * either from target object, or geometry. */
67 if (r_size != nullptr) {
68 if (ob_center != nullptr) {
69 /* Using 'scale' as 'size' here. The input object is typically an empty
70 * who's scale is used to define an ellipsoid instead of a simple sphere. */
71
72 /* Not we are not interested in signs here - they are even troublesome actually,
73 * due to security clamping! */
74 *r_size = math::abs(float3(ob_center->scale));
75 }
76 else {
77 /* Set size. */
78 sub_v3_v3v3(*r_size, max_co, min_co);
79 }
80
81 /* Error checks - we do not want one or more of our sizes to be null! */
82 if (is_zero_v3(*r_size)) {
83 *r_size = float3(1.0f);
84 }
85 else {
86 CLAMP_MIN((*r_size)[0], FLT_EPSILON);
87 CLAMP_MIN((*r_size)[1], FLT_EPSILON);
88 CLAMP_MIN((*r_size)[2], FLT_EPSILON);
89 }
90 }
91
92 if (ob_center != nullptr) {
93 float inv_obmat[4][4];
94
95 /* Translate our coordinates so that center of ob_center is at (0, 0, 0). */
96 /* Get ob_center (world) coordinates in ob local coordinates.
97 * No need to take into account ob_center's space here, see #44027. */
98 invert_m4_m4(inv_obmat, ob->object_to_world().ptr());
99 mul_v3_m4v3(diff, inv_obmat, ob_center->object_to_world().location());
101
102 do_diff = true;
103 }
104 else if (offset != nullptr && !is_zero_v3(offset)) {
105 negate_v3_v3(diff, offset);
106
107 do_diff = true;
108 }
109 /* Else, no need to change coordinates! */
110
111 if (do_diff) {
112 int i = verts_num;
113 while (i--) {
114 add_v3_v3(r_cos[i], diff);
115 }
116 }
117}
118
119/* Note this modifies nos_new in-place. */
120static void mix_normals(const float mix_factor,
121 const MDeformVert *dvert,
122 const int defgrp_index,
123 const bool use_invert_vgroup,
124 const float mix_limit,
125 const short mix_mode,
126 const int verts_num,
127 const Span<int> corner_verts,
128 float3 *nos_old,
129 float3 *nos_new)
130{
131 /* Mix with org normals... */
132 float *facs = nullptr, *wfac;
133 float3 *no_new, *no_old;
134 int i;
135
136 if (dvert) {
137 facs = MEM_new_array_uninitialized<float>(size_t(corner_verts.size()), __func__);
139 dvert, defgrp_index, verts_num, corner_verts, use_invert_vgroup, facs);
140 }
141
142 for (i = corner_verts.size(), no_new = nos_new, no_old = nos_old, wfac = facs; i--;
143 no_new++, no_old++, wfac++)
144 {
145 const float fac = facs ? *wfac * mix_factor : mix_factor;
146
147 switch (mix_mode) {
149 add_v3_v3(*no_new, *no_old);
150 normalize_v3(*no_new);
151 break;
153 sub_v3_v3(*no_new, *no_old);
154 normalize_v3(*no_new);
155 break;
157 mul_v3_v3(*no_new, *no_old);
158 normalize_v3(*no_new);
159 break;
161 break;
162 }
163
165 *no_new,
166 *no_old,
167 *no_new,
168 (mix_limit < float(M_PI)) ? min_ff(fac, mix_limit / angle_v3v3(*no_new, *no_old)) : fac);
169 }
170
171 MEM_SAFE_DELETE(facs);
172}
173
174/* Check face normals and new loop normals are compatible, otherwise flip faces
175 * (and invert matching face normals). */
176static void faces_check_flip(Mesh &mesh, MutableSpan<float3> nos, const Span<float3> face_normals)
177{
178 const OffsetIndices faces = mesh.faces();
179 IndexMaskMemory memory;
180 const IndexMask faces_to_flip = IndexMask::from_predicate(
181 faces.index_range(), memory, [&](const int i) {
182 const IndexRange face = faces[i];
183 float norsum[3] = {0.0f};
184
185 for (const int64_t j : face) {
186 add_v3_v3(norsum, nos[j]);
187 }
188 if (!normalize_v3(norsum)) {
189 return false;
190 }
191
192 /* If average of new loop normals is opposed to face normal, flip face. */
193 if (dot_v3v3(face_normals[i], norsum) < 0.0f) {
194 nos.slice(faces[i].drop_front(1)).reverse();
195 return true;
196 }
197 return false;
198 });
199
200 bke::mesh_flip_faces(mesh, faces_to_flip);
201}
202
204 const ModifierEvalContext * /*ctx*/,
205 Object *ob,
206 Mesh *mesh,
207 MutableSpan<short2> clnors,
208 MutableSpan<float3> corner_normals,
209 const short mix_mode,
210 const float mix_factor,
211 const float mix_limit,
212 const MDeformVert *dvert,
213 const int defgrp_index,
214 const bool use_invert_vgroup,
215 Span<float3> vert_positions,
216 MutableSpan<bool> sharp_edges,
217 MutableSpan<int> corner_verts,
218 MutableSpan<int> corner_edges,
219 const OffsetIndices<int> faces)
220{
221 Object *ob_target = enmd->target;
222
223 const bool do_facenors_fix = (enmd->flag & MOD_NORMALEDIT_NO_POLYNORS_FIX) == 0;
224
225 float (*cos)[3] = MEM_new_array_uninitialized<float[3]>(size_t(vert_positions.size()), __func__);
226 Array<float3> nos(corner_verts.size());
227 float3 size;
228
229 BLI_bitmap *done_verts = BLI_BITMAP_NEW(size_t(vert_positions.size()), __func__);
230
231 generate_vert_coordinates(mesh, ob, ob_target, enmd->offset, vert_positions.size(), cos, &size);
232
264 {
265 const float a = size[0], b = size[1], c = size[2];
266 const float m2 = (b * b) / (a * a);
267 const float n2 = (c * c) / (a * a);
268
269 /* We reuse cos to now store the ellipsoid-normal of the verts! */
270 for (const int64_t i : corner_verts.index_range()) {
271 const int vidx = corner_verts[i];
272 float *co = cos[vidx];
273
274 if (!BLI_BITMAP_TEST(done_verts, vidx)) {
275 const float x2 = co[0] * co[0];
276 const float y2 = co[1] * co[1];
277 const float z2 = co[2] * co[2];
278 const float a2 = x2 + (y2 / m2) + (z2 / n2);
279 const float b2 = (m2 * x2) + y2 + (m2 * z2 / n2);
280 const float c2 = (n2 * x2) + (n2 * y2 / m2) + z2;
281
282 co[0] /= a2;
283 co[1] /= b2;
284 co[2] /= c2;
285 normalize_v3(co);
286
287 BLI_BITMAP_ENABLE(done_verts, vidx);
288 }
289 nos[i] = co;
290 }
291 }
292
293 if (!corner_normals.is_empty()) {
294 mix_normals(mix_factor,
295 dvert,
296 defgrp_index,
297 use_invert_vgroup,
298 mix_limit,
299 mix_mode,
300 vert_positions.size(),
301 corner_verts,
302 corner_normals.data(),
303 nos.data());
304 }
305
306 if (do_facenors_fix) {
307 faces_check_flip(*mesh, nos, mesh->face_normals_true());
308 }
309 const bke::AttributeAccessor attributes = mesh->attributes();
310 const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", bke::AttrDomain::Face);
312 faces,
313 corner_verts,
314 corner_edges,
315 mesh->vert_to_face_map(),
316 mesh->vert_normals_true(),
317 mesh->face_normals_true(),
318 sharp_faces,
319 sharp_edges,
320 nos,
321 clnors);
322
323 MEM_delete(cos);
324 MEM_delete(done_verts);
325}
326
328 const ModifierEvalContext * /*ctx*/,
329 Object *ob,
330 Mesh *mesh,
331 MutableSpan<short2> clnors,
332 MutableSpan<float3> corner_normals,
333 const short mix_mode,
334 const float mix_factor,
335 const float mix_limit,
336 const MDeformVert *dvert,
337 const int defgrp_index,
338 const bool use_invert_vgroup,
339 const Span<float3> positions,
340 MutableSpan<bool> sharp_edges,
341 MutableSpan<int> corner_verts,
342 MutableSpan<int> corner_edges,
343 const OffsetIndices<int> faces)
344{
345 Object *ob_target = enmd->target;
346
347 const bool do_facenors_fix = (enmd->flag & MOD_NORMALEDIT_NO_POLYNORS_FIX) == 0;
348 const bool use_parallel_normals = (enmd->flag & MOD_NORMALEDIT_USE_DIRECTION_PARALLEL) != 0;
349
350 Array<float3> nos(corner_verts.size());
351
352 float target_co[3];
353 int i;
354
355 /* Get target's center coordinates in ob local coordinates. */
356 float mat[4][4];
357
358 invert_m4_m4(mat, ob->object_to_world().ptr());
359 mul_m4_m4m4(mat, mat, ob_target->object_to_world().ptr());
360 copy_v3_v3(target_co, mat[3]);
361
362 if (use_parallel_normals) {
363 float no[3];
364
365 sub_v3_v3v3(no, target_co, enmd->offset);
366 normalize_v3(no);
367
368 for (i = corner_verts.size(); i--;) {
369 copy_v3_v3(nos[i], no);
370 }
371 }
372 else {
373 float (*cos)[3] = MEM_new_array_uninitialized<float[3]>(size_t(positions.size()), __func__);
374 generate_vert_coordinates(mesh, ob, ob_target, nullptr, positions.size(), cos, nullptr);
375
376 BLI_bitmap *done_verts = BLI_BITMAP_NEW(size_t(positions.size()), __func__);
377
378 /* We reuse cos to now store the 'to target' normal of the verts! */
379 for (const int64_t i : corner_verts.index_range()) {
380 const int vidx = corner_verts[i];
381 float *co = cos[vidx];
382
383 if (!BLI_BITMAP_TEST(done_verts, vidx)) {
384 sub_v3_v3v3(co, target_co, co);
385 normalize_v3(co);
386
387 BLI_BITMAP_ENABLE(done_verts, vidx);
388 }
389 nos[i] = co;
390 }
391
392 MEM_delete(done_verts);
393 MEM_delete(cos);
394 }
395
396 if (!corner_normals.is_empty()) {
397 mix_normals(mix_factor,
398 dvert,
399 defgrp_index,
400 use_invert_vgroup,
401 mix_limit,
402 mix_mode,
403 positions.size(),
404 corner_verts,
405 corner_normals.data(),
406 nos.data());
407 }
408
409 if (do_facenors_fix) {
410 faces_check_flip(*mesh, nos, mesh->face_normals_true());
411 }
412 const bke::AttributeAccessor attributes = mesh->attributes();
413 const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", bke::AttrDomain::Face);
415 faces,
416 corner_verts,
417 corner_edges,
418 mesh->vert_to_face_map(),
419 mesh->vert_normals_true(),
420 mesh->face_normals_true(),
421 sharp_faces,
422 sharp_edges,
423 nos,
424 clnors);
425}
426
428{
429 if (enmd->mode == MOD_NORMALEDIT_MODE_RADIAL) {
430 return true;
431 }
432 if ((enmd->mode == MOD_NORMALEDIT_MODE_DIRECTIONAL) && enmd->target) {
433 return true;
434 }
435 return false;
436}
437
439{
440 if (is_valid_target(enmd)) {
441 return true;
442 }
443 BKE_modifier_set_error(ob, reinterpret_cast<ModifierData *>(enmd), "Invalid target settings");
444 return false;
445}
446
448 const ModifierEvalContext *ctx,
449 Object *ob,
450 Mesh *mesh)
451{
452 const bool use_invert_vgroup = ((enmd->flag & MOD_NORMALEDIT_INVERT_VGROUP) != 0);
453 const bool use_current_clnors = !((enmd->mix_mode == MOD_NORMALEDIT_MIX_COPY) &&
454 (enmd->mix_factor == 1.0f) && (enmd->defgrp_name[0] == '\0') &&
455 (enmd->mix_limit == float(M_PI)));
456
457 /* Do not run that modifier at all if auto-smooth is disabled! */
458 if (!is_valid_target_with_error(ctx->object, enmd) || mesh->corners_num == 0) {
459 return mesh;
460 }
461
462 Mesh *result;
463 if (mesh->edges().data() == (id_cast<Mesh *>(ob->data))->edges().data()) {
464 /* We need to duplicate data here, otherwise setting custom normals
465 * (which may also affect sharp edges) could
466 * modify original mesh, see #43671. */
467 result = id_cast<Mesh *>(BKE_id_copy_ex(nullptr, &mesh->id, nullptr, LIB_ID_COPY_LOCALIZE));
468 }
469 else {
470 result = mesh;
471 }
472
473 const Span<float3> positions = result->vert_positions();
474 const OffsetIndices faces = result->faces();
475 MutableSpan<int> corner_verts = result->corner_verts_for_write();
476 MutableSpan<int> corner_edges = result->corner_edges_for_write();
477
478 int defgrp_index;
479 const MDeformVert *dvert;
480
481 Array<float3> corner_normals;
482
483 bke::MutableAttributeAccessor attributes = result->attributes_for_write();
485 "sharp_edge", bke::AttrDomain::Edge);
486
488 "custom_normal", bke::AttrDomain::Corner);
489 if (!custom_nors_dst) {
490 return result;
491 }
492 if (use_current_clnors) {
493 corner_normals.reinitialize(corner_verts.size());
494 const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", bke::AttrDomain::Face);
496 faces,
497 corner_verts,
498 corner_edges,
499 result->vert_to_face_map(),
500 result->face_normals_true(),
501 sharp_edges.span,
502 sharp_faces,
503 custom_nors_dst.span,
504 nullptr,
505 corner_normals);
506 }
507
508 MOD_get_vgroup(ob, result, enmd->defgrp_name, &dvert, &defgrp_index);
509
510 if (enmd->mode == MOD_NORMALEDIT_MODE_RADIAL) {
512 ctx,
513 ob,
514 result,
515 custom_nors_dst.span,
516 corner_normals,
517 enmd->mix_mode,
518 enmd->mix_factor,
519 enmd->mix_limit,
520 dvert,
521 defgrp_index,
522 use_invert_vgroup,
523 positions,
524 sharp_edges.span,
525 corner_verts,
526 corner_edges,
527 faces);
528 }
529 else if (enmd->mode == MOD_NORMALEDIT_MODE_DIRECTIONAL) {
531 ctx,
532 ob,
533 result,
534 custom_nors_dst.span,
535 corner_normals,
536 enmd->mix_mode,
537 enmd->mix_factor,
538 enmd->mix_limit,
539 dvert,
540 defgrp_index,
541 use_invert_vgroup,
542 positions,
543 sharp_edges.span,
544 corner_verts,
545 corner_edges,
546 faces);
547 }
548
549 result->runtime->is_original_bmesh = false;
550
551 custom_nors_dst.finish();
552 sharp_edges.finish();
553
554 return result;
555}
556
557static void init_data(ModifierData *md)
558{
559 NormalEditModifierData *enmd = reinterpret_cast<NormalEditModifierData *>(md);
561}
562
563static void required_data_mask(ModifierData *md, CustomData_MeshMasks *r_cddata_masks)
564{
565 NormalEditModifierData *enmd = reinterpret_cast<NormalEditModifierData *>(md);
566
567 /* Ask for vertex-groups if we need them. */
568 if (enmd->defgrp_name[0] != '\0') {
569 r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
570 }
571}
572
573static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
574{
575 NormalEditModifierData *enmd = reinterpret_cast<NormalEditModifierData *>(md);
576
577 walk(user_data, ob, reinterpret_cast<ID **>(&enmd->target), IDWALK_CB_NOP);
578}
579
580static bool is_disabled(const Scene * /*scene*/, ModifierData *md, bool /*use_render_params*/)
581{
582 NormalEditModifierData *enmd = reinterpret_cast<NormalEditModifierData *>(md);
583
584 return !is_valid_target(enmd);
585}
586
588{
589 NormalEditModifierData *enmd = reinterpret_cast<NormalEditModifierData *>(md);
590 if (enmd->target) {
591 DEG_add_object_relation(ctx->node, enmd->target, DEG_OB_COMP_TRANSFORM, "NormalEdit Modifier");
592 DEG_add_depends_on_transform_relation(ctx->node, "NormalEdit Modifier");
593 }
594}
595
597{
599 reinterpret_cast<NormalEditModifierData *>(md), ctx, ctx->object, mesh);
600}
601
602static void panel_draw(const bContext * /*C*/, Panel *panel)
603{
604 ui::Layout &layout = *panel->layout;
605
606 PointerRNA ob_ptr;
608
609 int mode = RNA_enum_get(ptr, "mode");
610
611 layout.prop(ptr, "mode", ui::ITEM_R_EXPAND, std::nullopt, ICON_NONE);
612
613 layout.use_property_split_set(true);
614
615 layout.prop(ptr, "target", UI_ITEM_NONE, std::nullopt, ICON_NONE);
616
617 ui::Layout &col = layout.column(false);
619 col.prop(ptr, "use_direction_parallel", UI_ITEM_NONE, std::nullopt, ICON_NONE);
620
621 modifier_error_message_draw(layout, ptr);
622}
623
624/* This panel could be open by default, but it isn't currently. */
625static void mix_mode_panel_draw(const bContext * /*C*/, Panel *panel)
626{
627 ui::Layout &layout = *panel->layout;
628
629 PointerRNA ob_ptr;
631
632 layout.use_property_split_set(true);
633
634 layout.prop(ptr, "mix_mode", UI_ITEM_NONE, std::nullopt, ICON_NONE);
635 layout.prop(ptr, "mix_factor", UI_ITEM_NONE, std::nullopt, ICON_NONE);
636
637 modifier_vgroup_ui(layout, ptr, &ob_ptr, "vertex_group", "invert_vertex_group", std::nullopt);
638
639 ui::Layout &row = layout.row(true);
640 row.prop(ptr, "mix_limit", UI_ITEM_NONE, std::nullopt, ICON_NONE);
641 row.prop(ptr,
642 "no_polynors_fix",
644 "",
645 (RNA_boolean_get(ptr, "no_polynors_fix") ? ICON_LOCKED : ICON_UNLOCKED));
646}
647
648static void offset_panel_draw(const bContext * /*C*/, Panel *panel)
649{
650 ui::Layout &layout = *panel->layout;
651
653
654 int mode = RNA_enum_get(ptr, "mode");
655 PointerRNA target_ptr = RNA_pointer_get(ptr, "target");
656 bool needs_object_offset = (mode == MOD_NORMALEDIT_MODE_RADIAL && !target_ptr) ||
658 RNA_boolean_get(ptr, "use_direction_parallel"));
659
660 layout.use_property_split_set(true);
661
662 layout.active_set(needs_object_offset);
663 layout.prop(ptr, "offset", UI_ITEM_NONE, std::nullopt, ICON_NONE);
664}
665
666static void panel_register(ARegionType *region_type)
667{
670 modifier_subpanel_register(region_type, "mix", "Mix", nullptr, mix_mode_panel_draw, panel_type);
672 region_type, "offset", "Offset", nullptr, offset_panel_draw, panel_type);
673}
674
676 /*idname*/ "NormalEdit",
677 /*name*/ N_("NormalEdit"),
678 /*struct_name*/ "NormalEditModifierData",
679 /*struct_size*/ sizeof(NormalEditModifierData),
680 /*srna*/ &RNA_NormalEditModifier,
684 /*icon*/ ICON_MOD_NORMALEDIT,
685
686 /*copy_data*/ BKE_modifier_copydata_generic,
687
688 /*deform_verts*/ nullptr,
689 /*deform_matrices*/ nullptr,
690 /*deform_verts_EM*/ nullptr,
691 /*deform_matrices_EM*/ nullptr,
692 /*modify_mesh*/ modify_mesh,
693 /*modify_geometry_set*/ nullptr,
694
695 /*init_data*/ init_data,
696 /*required_data_mask*/ required_data_mask,
697 /*free_data*/ nullptr,
698 /*is_disabled*/ is_disabled,
699 /*update_depsgraph*/ update_depsgraph,
700 /*depends_on_time*/ nullptr,
701 /*depends_on_normals*/ nullptr,
702 /*foreach_ID_link*/ foreach_ID_link,
703 /*foreach_tex_link*/ nullptr,
704 /*free_runtime_data*/ nullptr,
705 /*panel_register*/ panel_register,
706 /*blend_write*/ nullptr,
707 /*blend_read*/ nullptr,
708 /*foreach_cache*/ nullptr,
709 /*foreach_working_space_color*/ nullptr,
710};
711
712} // namespace blender
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
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define UI_ITEM_NONE
#define INIT_MINMAX(min, max)
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
#define CLAMP_MIN(a, b)
#define CD_MASK_MDEFORMVERT
const T * data() const
Definition BLI_array.hh:323
void reinitialize(const int64_t new_size)
Definition BLI_array.hh:430
static IndexMask from_predicate(const IndexMask &universe, LinearAllocator<> &memory, Fn &&predicate, exec_mode::Mode mode=exec_mode::parallel)
constexpr int64_t size() const
Definition BLI_span.hh:499
constexpr MutableSpan slice(const int64_t start, const int64_t size) const
Definition BLI_span.hh:579
constexpr bool is_empty() const
Definition BLI_span.hh:515
constexpr T * data() const
Definition BLI_span.hh:545
constexpr IndexRange index_range() const
Definition BLI_span.hh:676
constexpr int64_t size() const
Definition BLI_span.hh:256
GAttributeReader lookup(const StringRef name) const
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
constexpr void reverse() const
IMETHOD Vector diff(const Vector &a, const Vector &b, double dt)
Definition frames.inl:1166
#define FLT_EPSILON
#define cos
void normals_calc_corners(Span< float3 > vert_positions, OffsetIndices< int > faces, Span< int > corner_verts, Span< int > corner_edges, GroupedSpan< int > vert_to_face_map, Span< float3 > face_normals, Span< bool > sharp_edges, Span< bool > sharp_faces, Span< short2 > custom_normals, CornerNormalSpaceArray *r_fan_spaces, MutableSpan< float3 > r_corner_normals)
void normals_corner_custom_set(Span< float3 > vert_positions, OffsetIndices< int > faces, Span< int > corner_verts, Span< int > corner_edges, GroupedSpan< int > vert_to_face_map, Span< float3 > vert_normals, Span< float3 > face_normals, Span< bool > sharp_faces, MutableSpan< bool > sharp_edges, MutableSpan< float3 > r_custom_corner_normals, MutableSpan< short2 > r_clnors_data)
void mesh_flip_faces(Mesh &mesh, const IndexMask &selection)
T abs(const T &a)
BMesh Iterators.
MINLINE float min_ff(float a, float b)
MINLINE void negate_v3_v3(float r[3], const float a[3])
@ MOD_NORMALEDIT_NO_POLYNORS_FIX
@ MOD_NORMALEDIT_USE_DIRECTION_PARALLEL
__int64 int64_t
Definition BKE_text.h:90
int RNA_enum_get(PointerRNA *ptr, const char *name)
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)
@ MOD_NORMALEDIT_MODE_DIRECTIONAL
static void generate_vert_coordinates(Mesh *mesh, Object *ob, Object *ob_center, const float offset[3], const int verts_num, float(*r_cos)[3], float3 *r_size)
MINLINE void copy_v3_v3(float r[3], const float a[3])
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void minmax_v3v3_v3(float min[3], float max[3], const float vec[3])
static void offset_panel_draw(const bContext *, Panel *panel)
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
float angle_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
bool invert_m4_m4(float inverse[4][4], const float mat[4][4])
static void normalEditModifier_do_radial(NormalEditModifierData *enmd, const ModifierEvalContext *, Object *ob, Mesh *mesh, MutableSpan< short2 > clnors, MutableSpan< float3 > corner_normals, const short mix_mode, const float mix_factor, const float mix_limit, const MDeformVert *dvert, const int defgrp_index, const bool use_invert_vgroup, Span< float3 > vert_positions, MutableSpan< bool > sharp_edges, MutableSpan< int > corner_verts, MutableSpan< int > corner_edges, const OffsetIndices< int > faces)
static void init_data(ModifierData *md)
void(*)(void *user_data, Object *ob, ID **idpoin, LibraryForeachIDCallbackFlag cb_flag) IDWalkFunc
static void update_depsgraph(tGraphSliderOp *gso)
static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
void DEG_add_object_relation(DepsNodeHandle *node_handle, Object *object, eDepsObjectComponentType component, const char *description)
void DEG_add_depends_on_transform_relation(DepsNodeHandle *node_handle, const char *description)
@ LIB_ID_COPY_LOCALIZE
static void required_data_mask(ModifierData *, CustomData_MeshMasks *r_cddata_masks)
static void faces_check_flip(Mesh &mesh, MutableSpan< float3 > nos, const Span< float3 > face_normals)
MINLINE void sub_v3_v3(float r[3], const float a[3])
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
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)
MINLINE void mul_v3_v3(float r[3], const float a[3])
static void panel_register(ARegionType *region_type)
void BKE_defvert_extract_vgroup_to_loopweights(const MDeformVert *dvert, int defgroup, int verts_num, Span< int > corner_verts, bool invert_vgroup, float *r_weights)
Definition deform.cc:1140
MINLINE void negate_v3(float r[3])
static Mesh * normalEditModifier_do(NormalEditModifierData *enmd, const ModifierEvalContext *ctx, Object *ob, Mesh *mesh)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
static Mesh * modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh)
Definition MOD_array.cc:873
@ eModifierTypeFlag_SupportsMapping
@ eModifierTypeFlag_EnableInEditmode
@ eModifierTypeFlag_SupportsEditmode
@ eModifierTypeFlag_AcceptsMesh
PointerRNA RNA_pointer_get(PointerRNA *ptr, const char *name)
void interp_v3_v3v3_slerp_safe(float target[3], const float a[3], const float b[3], float t)
static void mix_normals(const float mix_factor, const MDeformVert *dvert, const int defgrp_index, const bool use_invert_vgroup, const float mix_limit, const short mix_mode, const int verts_num, const Span< int > corner_verts, float3 *nos_old, float3 *nos_new)
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
static void mix_mode_panel_draw(const bContext *, Panel *panel)
VecBase< int16_t, 2 > short2
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
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)
ID * BKE_id_copy_ex(Main *bmain, const ID *id, ID **new_id_p, int flag)
Definition lib_id.cc:851
VecBase< float, 3 > float3
static bool is_disabled(const Scene *, ModifierData *md, bool)
static void normalEditModifier_do_directional(NormalEditModifierData *enmd, const ModifierEvalContext *, Object *ob, Mesh *mesh, MutableSpan< short2 > clnors, MutableSpan< float3 > corner_normals, const short mix_mode, const float mix_factor, const float mix_limit, const MDeformVert *dvert, const int defgrp_index, const bool use_invert_vgroup, const Span< float3 > positions, MutableSpan< bool > sharp_edges, MutableSpan< int > corner_verts, MutableSpan< int > corner_edges, const OffsetIndices< int > faces)
MINLINE float dot_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
ModifierTypeInfo modifierType_NormalEdit
static bool is_valid_target_with_error(const Object *ob, NormalEditModifierData *enmd)
MINLINE bool is_zero_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
static bool is_valid_target(NormalEditModifierData *enmd)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
NormalEditModifierMixMode mix_mode
ui::Layout * layout
void use_property_split_set(bool is_sep)
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)
void active_set(bool active)
Layout & column(bool align)
Layout & row(bool align)
#define N_(msgid)