Blender V5.3
object_data_transfer.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2014 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "DNA_mesh_types.h"
10#include "DNA_modifier_types.h"
11#include "DNA_object_types.h"
12
13#include "BLI_math_matrix_c.hh"
14#include "BLI_string.hh"
15#include "BLI_utildefines.hh"
16
17#include "BKE_context.hh"
18#include "BKE_customdata.hh"
19#include "BKE_data_transfer.h"
20#include "BKE_deform.hh"
21#include "BKE_library.hh"
22#include "BKE_mesh_remap.hh"
23#include "BKE_object.hh"
24#include "BKE_report.hh"
25
26#include "DEG_depsgraph.hh"
28
29#include "BLT_translation.hh"
30
31#include "RNA_access.hh"
32#include "RNA_define.hh"
33#include "RNA_enum_types.hh"
34#include "RNA_prototypes.hh"
35
36#include "WM_api.hh"
37#include "WM_types.hh"
38
39#include "ED_object.hh"
40
41#include "object_intern.hh"
42
43namespace blender::ed::object {
44
45/* All possible data to transfer.
46 * Note some are 'fake' ones, i.e. they are not hold by real CDLayers. */
47/* Not shared with modifier, since we use a usual enum here, not a multi-choice one. */
49 RNA_ENUM_ITEM_HEADING(N_("Vertex Data"), nullptr),
51 "VGROUP_WEIGHTS",
52 0,
53 "Vertex Group(s)",
54 "Transfer active or all vertex groups"},
55 {DT_TYPE_BWEIGHT_VERT, "BEVEL_WEIGHT_VERT", 0, "Bevel Weight", "Transfer bevel weights"},
57 "COLOR_VERTEX",
58 0,
59 "Colors",
60 "Color Attributes"},
61
62 RNA_ENUM_ITEM_HEADING(N_("Edge Data"), nullptr),
63 {DT_TYPE_SHARP_EDGE, "SHARP_EDGE", 0, "Sharp", "Transfer sharp mark"},
64 {DT_TYPE_SEAM, "SEAM", 0, "UV Seam", "Transfer UV seam mark"},
65 {DT_TYPE_CREASE, "CREASE", 0, "Subdivision Crease", "Transfer crease values"},
66 {DT_TYPE_BWEIGHT_EDGE, "BEVEL_WEIGHT_EDGE", 0, "Bevel Weight", "Transfer bevel weights"},
68 "FREESTYLE_EDGE",
69 0,
70 "Freestyle Mark",
71 "Transfer Freestyle edge mark"},
72
73 RNA_ENUM_ITEM_HEADING(N_("Face Corner Data"), nullptr),
74 {DT_TYPE_LNOR, "CUSTOM_NORMAL", 0, "Custom Normals", "Transfer custom normals"},
76 "COLOR_CORNER",
77 0,
78 "Colors",
79 "Color Attributes"},
80 {DT_TYPE_UV, "UV", 0, "UVs", "Transfer UV layers"},
81
82 RNA_ENUM_ITEM_HEADING(N_("Face Data"), nullptr),
83 {DT_TYPE_SHARP_FACE, "SMOOTH", 0, "Smooth", "Transfer flat/smooth mark"},
85 "FREESTYLE_FACE",
86 0,
87 "Freestyle Mark",
88 "Transfer Freestyle face mark"},
89 {0, nullptr, 0, nullptr, nullptr},
90};
91
92static void dt_add_vcol_layers(const CustomData *cdata,
94 EnumPropertyItem **r_item,
95 int *r_totitem)
96{
97 const int types[2] = {CD_PROP_COLOR, CD_PROP_BYTE_COLOR};
98 int idx = 0;
99 for (int i = 0; i < 2; i++) {
100 eCustomDataType type = eCustomDataType(types[i]);
101
102 if (!(mask & CD_TYPE_AS_MASK(type))) {
103 continue;
104 }
105
106 int data_num = CustomData_number_of_layers(cdata, type);
107
108 RNA_enum_item_add_separator(r_item, r_totitem);
109
110 for (int j = 0; j < data_num; j++) {
111 EnumPropertyItem tmp_item = {0};
112 tmp_item.value = idx++;
113 tmp_item.identifier = tmp_item.name = CustomData_get_layer_name(cdata, type, j);
114 RNA_enum_item_add(r_item, r_totitem, &tmp_item);
115 }
116 }
117}
118/* NOTE: #rna_enum_dt_layers_select_src_items enum is from rna_modifier.cc. */
120 PointerRNA *ptr,
121 PropertyRNA * /*prop*/,
122 bool *r_free)
123{
124 if (!C) { /* needed for docs and i18n tools */
126 }
127
128 EnumPropertyItem *item = nullptr, tmp_item = {0};
129 int totitem = 0;
130 const int data_type = RNA_enum_get(ptr, "data_type");
131
132 PropertyRNA *prop = RNA_struct_find_property(ptr, "use_reverse_transfer");
133 const bool reverse_transfer = prop != nullptr && RNA_property_boolean_get(ptr, prop);
134 const int layers_select_dst = reverse_transfer ? RNA_enum_get(ptr, "layers_select_src") :
135 RNA_enum_get(ptr, "layers_select_dst");
136
137 if (!reverse_transfer || layers_select_dst == DT_LAYERS_ACTIVE_DST || layers_select_dst >= 0) {
140 }
143
144 Object *ob_src = context_active_object(C);
145 if (ob_src == nullptr) {
146 RNA_enum_item_end(&item, &totitem);
147 *r_free = true;
148 return item;
149 }
150
151 if (data_type == DT_TYPE_MDEFORMVERT && BKE_object_supports_vertex_groups(ob_src)) {
152 if (BKE_object_pose_armature_get(ob_src)) {
157 }
158
159 const bDeformGroup *dg;
160 int i;
161
162 RNA_enum_item_add_separator(&item, &totitem);
163
164 const ListBaseT<bDeformGroup> *defbase = BKE_object_defgroup_list(ob_src);
165 for (i = 0, dg = defbase->first(); dg; i++, dg = dg->next) {
166 tmp_item.value = i;
167 tmp_item.identifier = tmp_item.name = dg->name;
168 RNA_enum_item_add(&item, &totitem, &tmp_item);
169 }
170 }
171 else if (data_type == DT_TYPE_UV) {
172 const Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
173 const Object *ob_src_eval = DEG_get_evaluated(depsgraph, ob_src);
174 const Mesh *mesh_eval = BKE_object_get_evaluated_mesh_no_subsurf(ob_src_eval);
175 if (!mesh_eval) {
176 RNA_enum_item_end(&item, &totitem);
177 *r_free = true;
178 return item;
179 }
180 VectorSet<StringRefNull> uv_map_names = mesh_eval->uv_map_names();
181 RNA_enum_item_add_separator(&item, &totitem);
182
183 for (int i = 0; i < uv_map_names.size(); i++) {
184 tmp_item.value = i;
185 tmp_item.identifier = tmp_item.name = uv_map_names[i].c_str();
186 RNA_enum_item_add(&item, &totitem, &tmp_item);
187 }
188 }
189 else if (data_type & DT_TYPE_VCOL_ALL) {
190 const Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
191 const Object *ob_src_eval = DEG_get_evaluated(depsgraph, ob_src);
192 const Mesh *mesh_eval = BKE_object_get_evaluated_mesh_no_subsurf(ob_src_eval);
193 if (!mesh_eval) {
194 RNA_enum_item_end(&item, &totitem);
195 *r_free = true;
196 return item;
197 }
198
200 if (data_type & (DT_TYPE_MPROPCOL_VERT)) {
201 cddata_masks.vmask |= CD_MASK_PROP_COLOR;
202 }
203 if (data_type & (DT_TYPE_MLOOPCOL_VERT)) {
204 cddata_masks.vmask |= CD_MASK_PROP_BYTE_COLOR;
205 }
206
207 if (data_type & (DT_TYPE_MPROPCOL_LOOP)) {
208 cddata_masks.lmask |= CD_MASK_PROP_COLOR;
209 }
210 if (data_type & (DT_TYPE_MLOOPCOL_LOOP)) {
211 cddata_masks.lmask |= CD_MASK_PROP_BYTE_COLOR;
212 }
213
214 if (data_type & (DT_TYPE_MLOOPCOL_VERT | DT_TYPE_MPROPCOL_VERT)) {
215 dt_add_vcol_layers(&mesh_eval->vert_data, cddata_masks.vmask, &item, &totitem);
216 }
217 if (data_type & (DT_TYPE_MLOOPCOL_LOOP | DT_TYPE_MPROPCOL_LOOP)) {
218 dt_add_vcol_layers(&mesh_eval->corner_data, cddata_masks.lmask, &item, &totitem);
219 }
220 }
221
222 RNA_enum_item_end(&item, &totitem);
223 *r_free = true;
224
225 return item;
226}
227
228/* NOTE: #rna_enum_dt_layers_select_dst_items enum is from `rna_modifier.cc`. */
230 PointerRNA *ptr,
231 PropertyRNA * /*prop*/,
232 bool *r_free)
233{
234 if (!C) { /* needed for docs and i18n tools */
236 }
237
238 EnumPropertyItem *item = nullptr;
239 int totitem = 0;
240
241 PropertyRNA *prop = RNA_struct_find_property(ptr, "use_reverse_transfer");
242 const bool reverse_transfer = prop != nullptr && RNA_property_boolean_get(ptr, prop);
243 const int layers_select_src = reverse_transfer ? RNA_enum_get(ptr, "layers_select_dst") :
244 RNA_enum_get(ptr, "layers_select_src");
245
246 if (reverse_transfer || layers_select_src == DT_LAYERS_ACTIVE_SRC || layers_select_src >= 0) {
249 }
254
255 /* No 'specific' to-layers here, since we may transfer to several objects at once! */
256
257 RNA_enum_item_end(&item, &totitem);
258 *r_free = true;
259
260 return item;
261}
262
264 PointerRNA *ptr,
265 PropertyRNA *prop,
266 bool *r_free)
267{
268 const bool reverse_transfer = RNA_boolean_get(ptr, "use_reverse_transfer");
269
270 if (STREQ(RNA_property_identifier(prop), "layers_select_dst")) {
271 if (reverse_transfer) {
272 return dt_layers_select_src_itemf(C, ptr, prop, r_free);
273 }
274 return dt_layers_select_dst_itemf(C, ptr, prop, r_free);
275 }
276 if (reverse_transfer) {
277 return dt_layers_select_dst_itemf(C, ptr, prop, r_free);
278 }
279 return dt_layers_select_src_itemf(C, ptr, prop, r_free);
280}
281
282/* NOTE: rna_enum_dt_mix_mode_items enum is from `rna_modifier.cc`. */
284 PointerRNA *ptr,
285 PropertyRNA * /*prop*/,
286 bool *r_free)
287{
288 EnumPropertyItem *item = nullptr;
289 int totitem = 0;
290
291 const int dtdata_type = RNA_enum_get(ptr, "data_type");
292 bool support_advanced_mixing, support_threshold;
293
294 if (!C) { /* needed for docs and i18n tools */
296 }
297
299
301 dtdata_type, &support_advanced_mixing, &support_threshold);
302
303 if (support_threshold) {
308 }
309
310 if (support_advanced_mixing) {
311 RNA_enum_item_add_separator(&item, &totitem);
316 }
317
318 RNA_enum_item_end(&item, &totitem);
319 *r_free = true;
320
321 return item;
322}
323
324static bool data_transfer_check(bContext * /*C*/, wmOperator *op)
325{
326 const int layers_select_src = RNA_enum_get(op->ptr, "layers_select_src");
327 PropertyRNA *prop = RNA_struct_find_property(op->ptr, "layers_select_dst");
328 const int layers_select_dst = RNA_property_enum_get(op->ptr, prop);
329
330 /* TODO: check for invalid layers_src select modes too! */
331
332 if ((layers_select_src != DT_LAYERS_ACTIVE_SRC) && (layers_select_dst == DT_LAYERS_ACTIVE_DST)) {
334 return true;
335 }
336
337 return false;
338}
339
340/* Helper, used by both data_transfer_exec and datalayout_transfer_exec. */
342 wmOperator *op,
343 Object *ob_src,
344 Vector<PointerRNA> *ctx_objects,
345 const bool reverse_transfer)
346{
348
349 if (reverse_transfer) {
350 return; /* Nothing else to do in this case... */
351 }
352
353 for (const PointerRNA &ptr : *ctx_objects) {
354 Object *ob = static_cast<Object *>(ptr.data);
355 Mesh *mesh;
356 if ((ob == ob_src) || (ob->type != OB_MESH)) {
357 continue;
358 }
359
360 mesh = id_cast<Mesh *>(ob->data);
362 /* Do not transfer to linked/override data, not supported. */
365 "Skipping object '%s', linked or override data '%s' cannot be modified",
366 ob->id.name + 2,
367 mesh->id.name + 2);
368 mesh->id.tag &= ~ID_TAG_DOIT;
369 continue;
370 }
371
372 mesh->id.tag |= ID_TAG_DOIT;
373 }
374}
375
376/* Helper, used by both data_transfer_exec and datalayout_transfer_exec. */
378 Object *ob_src,
379 Object *ob_dst,
380 const bool reverse_transfer)
381{
382 Mesh *mesh;
383 if ((ob_dst == ob_src) || (ob_src->type != OB_MESH) || (ob_dst->type != OB_MESH)) {
384 return false;
385 }
386
387 if (reverse_transfer) {
388 return true;
389 }
390
391 mesh = id_cast<Mesh *>(ob_dst->data);
392 if (mesh->id.tag & ID_TAG_DOIT) {
393 mesh->id.tag &= ~ID_TAG_DOIT;
394 return true;
395 }
397 /* Do not apply transfer operation more than once. */
398 /* XXX This is not nice regarding vgroups, which are half-Object data... :/ */
400 op->reports,
402 "Skipping object '%s', data '%s' has already been processed with a previous object",
403 ob_dst->id.name + 2,
404 mesh->id.name + 2);
405 }
406 return false;
407}
408
410{
411 Object *ob_src = context_active_object(C);
412 Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
413
414 Vector<PointerRNA> ctx_objects;
415
416 bool changed = false;
417
418 const bool is_frozen = RNA_boolean_get(op->ptr, "use_freeze");
419
420 const bool reverse_transfer = RNA_boolean_get(op->ptr, "use_reverse_transfer");
421
422 const int data_type = RNA_enum_get(op->ptr, "data_type");
423 const bool use_create = RNA_boolean_get(op->ptr, "use_create");
424
425 const int map_vert_mode = RNA_enum_get(op->ptr, "vert_mapping");
426 const int map_edge_mode = RNA_enum_get(op->ptr, "edge_mapping");
427 const int map_loop_mode = RNA_enum_get(op->ptr, "loop_mapping");
428 const int map_poly_mode = RNA_enum_get(op->ptr, "poly_mapping");
429
430 const bool use_auto_transform = RNA_boolean_get(op->ptr, "use_auto_transform");
431 const bool use_object_transform = RNA_boolean_get(op->ptr, "use_object_transform");
432 const bool use_max_distance = RNA_boolean_get(op->ptr, "use_max_distance");
433 const float max_distance = use_max_distance ? RNA_float_get(op->ptr, "max_distance") : FLT_MAX;
434 const float ray_radius = RNA_float_get(op->ptr, "ray_radius");
435 const float islands_precision = RNA_float_get(op->ptr, "islands_precision");
436
437 int layers_src = RNA_enum_get(op->ptr, "layers_select_src");
438 int layers_dst = RNA_enum_get(op->ptr, "layers_select_dst");
439 int layers_select_src[DT_MULTILAYER_INDEX_MAX] = {0};
440 int layers_select_dst[DT_MULTILAYER_INDEX_MAX] = {0};
441 const int fromto_idx = BKE_object_data_transfer_dttype_to_srcdst_index(data_type);
442
443 const int mix_mode = RNA_enum_get(op->ptr, "mix_mode");
444 const float mix_factor = RNA_float_get(op->ptr, "mix_factor");
445
446 SpaceTransform space_transform_data;
447 SpaceTransform *space_transform = (use_object_transform && !use_auto_transform) ?
448 &space_transform_data :
449 nullptr;
450
451 if (is_frozen) {
453 op->reports,
454 RPT_INFO,
455 "Operator is frozen, changes to its settings won't take effect until you unfreeze it");
456 return OPERATOR_FINISHED;
457 }
458
459 if (reverse_transfer && (!ID_IS_EDITABLE(ob_src->data) || ID_IS_OVERRIDE_LIBRARY(ob_src->data)))
460 {
461 /* Do not transfer to linked or override data, not supported. */
462 return OPERATOR_CANCELLED;
463 }
464
465 if (reverse_transfer) {
466 std::swap(layers_src, layers_dst);
467 }
468
469 if (fromto_idx != DT_MULTILAYER_INDEX_INVALID) {
470 layers_select_src[fromto_idx] = layers_src;
471 layers_select_dst[fromto_idx] = layers_dst;
472 }
473
474 data_transfer_exec_preprocess_objects(C, op, ob_src, &ctx_objects, reverse_transfer);
475
476 int invalid_count = 0;
477
478 for (const PointerRNA &ptr : ctx_objects) {
479 Object *ob_dst = static_cast<Object *>(ptr.data);
480
481 if (reverse_transfer) {
482 std::swap(ob_src, ob_dst);
483 }
484
485 if (data_transfer_exec_is_object_valid(op, ob_src, ob_dst, reverse_transfer)) {
486 Object *ob_src_eval = DEG_get_evaluated(depsgraph, ob_src);
487
488 if (space_transform) {
489 Object *ob_dst_eval = DEG_get_evaluated(depsgraph, ob_dst);
490 BLI_SPACE_TRANSFORM_SETUP(space_transform, ob_dst_eval, ob_src_eval);
491 }
492
493 if (BKE_object_data_transfer_mesh(depsgraph,
494 ob_src_eval,
495 ob_dst,
496 data_type,
497 use_create,
498 map_vert_mode,
499 map_edge_mode,
500 map_loop_mode,
501 map_poly_mode,
502 space_transform,
503 use_auto_transform,
504 max_distance,
505 ray_radius,
506 islands_precision,
507 layers_select_src,
508 layers_select_dst,
509 mix_mode,
510 mix_factor,
511 nullptr,
512 false,
513 op->reports))
514 {
516 changed = true;
517 }
518 }
519 else {
520 /* Selected objects contains the active object, in this case `ob_src` is the same as
521 * `ob_dst`, so we don't treat this case as invalid. */
522 if (ob_src != ob_dst) {
523 invalid_count++;
524 }
525 }
526
527 if (reverse_transfer) {
528 std::swap(ob_src, ob_dst);
529 }
530 }
531
532 if (changed) {
535 }
536
537 if (invalid_count > 0) {
539 op->reports, RPT_WARNING, "Failed to transfer mesh data to %d objects", invalid_count);
540 }
541
542#if 0 /* TODO */
543 /* NOTE: issue with that is that if canceled, operator cannot be redone... Nasty in our case. */
544 return changed ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
545#else
546 return OPERATOR_FINISHED;
547#endif
548}
549
552{
553 /* Note this context poll is only really partial,
554 * it cannot check for all possible invalid cases. */
555
557 ID *data = (ob) ? ob->data : nullptr;
558 return (ob != nullptr && ob->type == OB_MESH && data != nullptr);
559}
560
562static bool data_transfer_poll_property(const bContext * /*C*/,
563 wmOperator *op,
564 const PropertyRNA *prop)
565{
566 PointerRNA *ptr = op->ptr;
567 PropertyRNA *prop_other;
568
569 const char *prop_id = RNA_property_identifier(prop);
570 const int data_type = RNA_enum_get(ptr, "data_type");
571 bool use_auto_transform = false;
572 bool use_max_distance = false;
573 bool use_modifier = false;
574
575 if ((prop_other = RNA_struct_find_property(ptr, "use_auto_transform"))) {
576 use_auto_transform = RNA_property_boolean_get(ptr, prop_other);
577 }
578 if ((prop_other = RNA_struct_find_property(ptr, "use_max_distance"))) {
579 use_max_distance = RNA_property_boolean_get(ptr, prop_other);
580 }
581 if ((prop_other = RNA_struct_find_property(ptr, "modifier"))) {
582 use_modifier = RNA_property_is_set(ptr, prop_other);
583 }
584
585 if (STREQ(prop_id, "modifier")) {
586 return use_modifier;
587 }
588
589 if (use_modifier) {
590 /* Hide everything but 'modifier' property, if set. */
591 return false;
592 }
593
594 if (STREQ(prop_id, "use_object_transform")) {
595 if (use_auto_transform) {
596 return false;
597 }
598 }
599 else if (STREQ(prop_id, "max_distance")) {
600 if (!use_max_distance) {
601 return false;
602 }
603 }
604 else if (STREQ(prop_id, "islands_precision")) {
605 if (!DT_DATATYPE_IS_LOOP(data_type)) {
606 return false;
607 }
608 }
609 else if (STREQ(prop_id, "vert_mapping")) {
610 if (!DT_DATATYPE_IS_VERT(data_type)) {
611 return false;
612 }
613 }
614 else if (STREQ(prop_id, "edge_mapping")) {
615 if (!DT_DATATYPE_IS_EDGE(data_type)) {
616 return false;
617 }
618 }
619 else if (STREQ(prop_id, "loop_mapping")) {
620 if (!DT_DATATYPE_IS_LOOP(data_type)) {
621 return false;
622 }
623 }
624 else if (STREQ(prop_id, "poly_mapping")) {
625 if (!DT_DATATYPE_IS_FACE(data_type)) {
626 return false;
627 }
628 }
629 else if (STR_ELEM(prop_id, "layers_select_src", "layers_select_dst")) {
630 if (!DT_DATATYPE_IS_MULTILAYERS(data_type)) {
631 return false;
632 }
633 }
634
635 /* Else, show it! */
636 return true;
637}
638
639static std::string data_transfer_get_description(bContext * /*C*/,
640 wmOperatorType * /*ot*/,
641 PointerRNA *ptr)
642{
643 const bool reverse_transfer = RNA_boolean_get(ptr, "use_reverse_transfer");
644
645 if (reverse_transfer) {
646 return TIP_(
647 "Transfer data layer(s) (weights, edge sharp, etc.) from selected meshes to active one");
648 }
649
650 return "";
651}
652
654{
655 PropertyRNA *prop;
656
657 /* Identifiers. */
658 ot->name = "Transfer Mesh Data";
659 ot->idname = "OBJECT_OT_data_transfer";
660 ot->description =
661 "Transfer data layer(s) (weights, edge sharp, etc.) from active to selected meshes";
662
663 /* API callbacks. */
670
671 /* Flags. */
673
674 /* Properties. */
675 prop = RNA_def_boolean(ot->srna,
676 "use_reverse_transfer",
677 false,
678 "Reverse Transfer",
679 "Transfer from selected objects to active one");
681
683 "use_freeze",
684 false,
685 "Freeze Operator",
686 "Prevent changes to settings to re-run the operator, "
687 "handy to change several things at once with heavy geometry");
688
689 /* Data type to transfer. */
690 ot->prop = RNA_def_enum(ot->srna,
691 "data_type",
693 /* The default is not significant, just use a valid value. */
695 "Data Type",
696 "Which data to transfer");
698 "use_create",
699 true,
700 "Create Data",
701 "Add data layers on destination meshes if needed");
702
703 /* Mapping methods. */
704 RNA_def_enum(ot->srna,
705 "vert_mapping",
708 "Vertex Mapping",
709 "Method used to map source vertices to destination ones");
710 RNA_def_enum(ot->srna,
711 "edge_mapping",
714 "Edge Mapping",
715 "Method used to map source edges to destination ones");
716 RNA_def_enum(ot->srna,
717 "loop_mapping",
720 "Face Corner Mapping",
721 "Method used to map source faces' corners to destination ones");
722 RNA_def_enum(ot->srna,
723 "poly_mapping",
726 "Face Mapping",
727 "Method used to map source faces to destination ones");
728
729 /* Mapping options and filtering. */
731 ot->srna,
732 "use_auto_transform",
733 false,
734 "Auto Transform",
735 "Automatically compute transformation to get the best possible match between source and "
736 "destination meshes.\n"
737 "Warning: Results will never be as good as manual matching of objects");
739 "use_object_transform",
740 true,
741 "Object Transform",
742 "Evaluate source and destination meshes in global space");
744 "use_max_distance",
745 false,
746 "Only Neighbor Geometry",
747 "Source elements must be closer than given distance from destination one");
748 prop = RNA_def_float(
749 ot->srna,
750 "max_distance",
751 1.0f,
752 0.0f,
753 FLT_MAX,
754 "Max Distance",
755 "Maximum allowed distance between source and destination element, for non-topology mappings",
756 0.0f,
757 100.0f);
759 prop = RNA_def_float(
760 ot->srna,
761 "ray_radius",
762 0.0f,
763 0.0f,
764 FLT_MAX,
765 "Ray Radius",
766 "'Width' of rays (especially useful when raycasting against vertices or edges)",
767 0.0f,
768 10.0f);
770 prop = RNA_def_float(
771 ot->srna,
772 "islands_precision",
773 0.1f,
774 0.0f,
775 10.0f,
776 "Islands Precision",
777 "Factor controlling precision of islands handling (the higher, the better the results)",
778 0.0f,
779 1.0f);
781
782 /* How to handle multi-layers types of data. */
783 prop = RNA_def_enum(ot->srna,
784 "layers_select_src",
787 "Source Layers Selection",
788 "Which layers to transfer, in case of multi-layers types");
790 prop, nullptr, nullptr, dt_layers_select_itemf, nullptr, nullptr);
791
792 prop = RNA_def_enum(ot->srna,
793 "layers_select_dst",
796 "Destination Layers Matching",
797 "How to match source and destination layers");
799 prop, nullptr, nullptr, dt_layers_select_itemf, nullptr, nullptr);
800
801 prop = RNA_def_enum(ot->srna,
802 "mix_mode",
805 "Mix Mode",
806 "How to affect destination elements with source values");
807 RNA_def_property_enum_funcs_runtime(prop, nullptr, nullptr, dt_mix_mode_itemf, nullptr, nullptr);
809 ot->srna,
810 "mix_factor",
811 1.0f,
812 0.0f,
813 1.0f,
814 "Mix Factor",
815 "Factor to use when applying data to destination (exact behavior depends on mix mode)",
816 0.0f,
817 1.0f);
818}
819
820/******************************************************************************/
821/* NOTE: This operator is hybrid, it can work as a usual standalone Object operator,
822 * or as a DataTransfer modifier tool.
823 */
824
826{
827 return (edit_modifier_poll_generic(C, RNA_DataTransferModifier, (1 << OB_MESH), true, false) ||
829}
830
832{
833 Object *ob_act = context_active_object(C);
834 Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
836
837 dtmd = reinterpret_cast<DataTransferModifierData *>(
839
840 /* If we have a modifier, we transfer data layout from this modifier's source object to
841 * active one. Else, we transfer data layout from active object to all selected ones. */
842 if (dtmd) {
843 Object *ob_src = dtmd->ob_source;
844 Object *ob_dst = ob_act;
845
846 const bool use_delete = false; /* Never when used from modifier, for now. */
847
848 if (!ob_src || !ID_IS_EDITABLE(ob_dst) || ID_IS_OVERRIDE_LIBRARY(ob_dst)) {
849 return OPERATOR_CANCELLED;
850 }
851
852 Object *ob_src_eval = DEG_get_evaluated(depsgraph, ob_src);
853
855 ob_src_eval,
856 ob_dst,
857 dtmd->data_types,
858 use_delete,
859 dtmd->layers_select_src,
860 dtmd->layers_select_dst);
861
863 }
864 else {
865 Object *ob_src = ob_act;
866
867 Vector<PointerRNA> ctx_objects;
868
869 const int data_type = RNA_enum_get(op->ptr, "data_type");
870 const bool use_delete = RNA_boolean_get(op->ptr, "use_delete");
871
872 const int layers_src = RNA_enum_get(op->ptr, "layers_select_src");
873 const int layers_dst = RNA_enum_get(op->ptr, "layers_select_dst");
874 int layers_select_src[DT_MULTILAYER_INDEX_MAX] = {0};
875 int layers_select_dst[DT_MULTILAYER_INDEX_MAX] = {0};
876 const int fromto_idx = BKE_object_data_transfer_dttype_to_srcdst_index(data_type);
877
878 if (fromto_idx != DT_MULTILAYER_INDEX_INVALID) {
879 layers_select_src[fromto_idx] = layers_src;
880 layers_select_dst[fromto_idx] = layers_dst;
881 }
882
883 Object *ob_src_eval = DEG_get_evaluated(depsgraph, ob_src);
884
885 data_transfer_exec_preprocess_objects(C, op, ob_src, &ctx_objects, false);
886
887 for (const PointerRNA &ptr : ctx_objects) {
888 Object *ob_dst = static_cast<Object *>(ptr.data);
889 if (data_transfer_exec_is_object_valid(op, ob_src, ob_dst, false)) {
891 ob_src_eval,
892 ob_dst,
893 data_type,
894 use_delete,
895 layers_select_src,
896 layers_select_dst);
897 }
898
900 }
901 }
902
905
906 return OPERATOR_FINISHED;
907}
908
910 wmOperator *op,
911 const wmEvent *event)
912{
914 return datalayout_transfer_exec(C, op);
915 }
916 return WM_menu_invoke(C, op, event);
917}
918
920{
921 PropertyRNA *prop;
922
923 ot->name = "Transfer Mesh Data Layout";
924 ot->description = "Transfer layout of data layer(s) from active to selected meshes";
925 ot->idname = "OBJECT_OT_datalayout_transfer";
926
932
933 /* flags */
935
936 /* Properties. */
938
939 /* Data type to transfer. */
940 ot->prop = RNA_def_enum(
941 ot->srna, "data_type", DT_layer_items, 0, "Data Type", "Which data to transfer");
943 "use_delete",
944 false,
945 "Exact Match",
946 "Also delete some data layers from destination if necessary, so that it matches "
947 "exactly source");
948
949 /* How to handle multi-layers types of data. */
950 prop = RNA_def_enum(ot->srna,
951 "layers_select_src",
954 "Source Layers Selection",
955 "Which layers to transfer, in case of multi-layers types");
957 prop, nullptr, nullptr, dt_layers_select_src_itemf, nullptr, nullptr);
958
959 prop = RNA_def_enum(ot->srna,
960 "layers_select_dst",
963 "Destination Layers Matching",
964 "How to match source and destination layers");
966 prop, nullptr, nullptr, dt_layers_select_dst_itemf, nullptr, nullptr);
967}
968
969} // namespace blender::ed::object
CustomData interface, see also DNA_customdata_types.h.
support for deformation groups and hooks.
General operations, lookup, etc. for blender objects.
#define BLI_SPACE_TRANSFORM_SETUP(data, local, target)
#define STR_ELEM(...)
#define TIP_(msgid)
#define ID_IS_EDITABLE(_id)
Definition DNA_ID.h:708
#define ID_IS_OVERRIDE_LIBRARY(_id)
Definition DNA_ID.h:736
#define DT_DATATYPE_IS_MULTILAYERS(_dt)
#define DT_DATATYPE_IS_LOOP(_dt)
#define DT_DATATYPE_IS_EDGE(_dt)
#define DT_DATATYPE_IS_FACE(_dt)
#define DT_DATATYPE_IS_VERT(_dt)
Object is a sort of wrapper for general info.
#define RNA_ENUM_ITEM_HEADING(name, description)
Definition RNA_types.hh:759
#define C
Definition RandGen.cpp:29
#define ND_DRAW
Definition WM_types.hh:502
#define NC_OBJECT
Definition WM_types.hh:392
#define STREQ(a, b)
#define CD_MASK_PROP_BYTE_COLOR
#define CD_MASK_PROP_COLOR
int64_t size() const
#define FLT_MAX
static wmOperatorStatus datalayout_transfer_exec(bContext *C, wmOperator *op)
static const EnumPropertyItem * dt_layers_select_src_itemf(bContext *C, PointerRNA *ptr, PropertyRNA *, bool *r_free)
static wmOperatorStatus datalayout_transfer_invoke(bContext *C, wmOperator *op, const wmEvent *event)
bool edit_modifier_invoke_properties(bContext *C, wmOperator *op)
void OBJECT_OT_data_transfer(wmOperatorType *ot)
void OBJECT_OT_datalayout_transfer(wmOperatorType *ot)
static std::string data_transfer_get_description(bContext *, wmOperatorType *, PointerRNA *ptr)
bool edit_modifier_poll_generic(bContext *C, StructRNA *rna_type, int obtype_flag, bool is_editmode_allowed, bool is_liboverride_allowed)
ModifierData * edit_modifier_property_get(wmOperator *op, Object *ob, int type)
static wmOperatorStatus data_transfer_exec(bContext *C, wmOperator *op)
Object * context_active_object(const bContext *C)
static const EnumPropertyItem * dt_layers_select_dst_itemf(bContext *C, PointerRNA *ptr, PropertyRNA *, bool *r_free)
static bool data_transfer_poll(bContext *C)
static const EnumPropertyItem DT_layer_items[]
static bool data_transfer_exec_is_object_valid(wmOperator *op, Object *ob_src, Object *ob_dst, const bool reverse_transfer)
static void dt_add_vcol_layers(const CustomData *cdata, eCustomDataMask mask, EnumPropertyItem **r_item, int *r_totitem)
static const EnumPropertyItem * dt_layers_select_itemf(bContext *C, PointerRNA *ptr, PropertyRNA *prop, bool *r_free)
static void data_transfer_exec_preprocess_objects(bContext *C, wmOperator *op, Object *ob_src, Vector< PointerRNA > *ctx_objects, const bool reverse_transfer)
static bool datalayout_transfer_poll(bContext *C)
static bool data_transfer_check(bContext *, wmOperator *op)
static const EnumPropertyItem * dt_mix_mode_itemf(bContext *C, PointerRNA *ptr, PropertyRNA *, bool *r_free)
static bool data_transfer_poll_property(const bContext *, wmOperator *op, const PropertyRNA *prop)
void edit_modifier_properties(wmOperatorType *ot)
@ CDT_MIX_REPLACE_ABOVE_THRESHOLD
@ CDT_MIX_REPLACE_BELOW_THRESHOLD
wmOperatorStatus WM_menu_invoke(bContext *C, wmOperator *op, const wmEvent *)
@ DT_MULTILAYER_INDEX_INVALID
void RNA_enum_item_add(EnumPropertyItem **items, int *totitem, const EnumPropertyItem *item)
int RNA_enum_get(PointerRNA *ptr, const char *name)
const CustomData_MeshMasks CD_MASK_BAREMESH
@ RPT_WARNING
Definition BKE_report.hh:40
const EnumPropertyItem rna_enum_dt_mix_mode_items[]
const EnumPropertyItem rna_enum_dt_layers_select_dst_items[]
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
int CustomData_number_of_layers(const CustomData *data, eCustomDataType type)
const ListBaseT< bDeformGroup > * BKE_object_defgroup_list(const Object *ob)
Definition deform.cc:591
@ MREMAP_MODE_LOOP_NEAREST_POLYNOR
const char * RNA_property_identifier(const PropertyRNA *prop)
int BKE_object_data_transfer_dttype_to_srcdst_index(int dtdata_type)
int RNA_property_enum_get(PointerRNA *ptr, PropertyRNA *prop)
@ eModifierType_DataTransfer
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
void BKE_object_data_transfer_layout(struct Depsgraph *depsgraph, struct Object *ob_src, struct Object *ob_dst, int data_types, bool use_delete, const int fromlayers_select[DT_MULTILAYER_INDEX_MAX], const int tolayers_select[DT_MULTILAYER_INDEX_MAX])
bool RNA_property_boolean_get(PointerRNA *ptr, PropertyRNA *prop)
uint64_t eCustomDataMask
bool BKE_object_supports_vertex_groups(const Object *ob)
Definition deform.cc:465
const EnumPropertyItem rna_enum_dt_method_edge_items[]
void DEG_id_tag_update(ID *id, unsigned int flags)
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition report.cc:162
BMesh const char void * data
Object * BKE_object_pose_armature_get(Object *ob)
Definition object.cc:2507
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C, bool rna_write_check=false)
bool BKE_object_data_transfer_get_dttypes_capacity(int dtdata_types, bool *r_advanced_mixing, bool *r_threshold)
bool BKE_object_data_transfer_mesh(struct Depsgraph *depsgraph, struct Object *ob_src, struct Object *ob_dst, int data_types, bool use_create, int map_vert_mode, int map_edge_mode, int map_loop_mode, int map_face_mode, struct SpaceTransform *space_transform, bool auto_transform, float max_distance, float ray_radius, float islands_handling_precision, const int fromlayers_select[DT_MULTILAYER_INDEX_MAX], const int tolayers_select[DT_MULTILAYER_INDEX_MAX], int mix_mode, float mix_factor, const char *vgroup_name, bool invert_vgroup, struct ReportList *reports)
@ DT_LAYERS_VGROUP_SRC_BONE_SELECT
@ DT_LAYERS_VGROUP_SRC_BONE_DEFORM
void RNA_def_property_subtype(PropertyRNA *prop, PropertySubType subtype)
const EnumPropertyItem rna_enum_dt_method_poly_items[]
void RNA_enum_items_add_value(EnumPropertyItem **items, int *totitem, const EnumPropertyItem *item, int value)
bool CTX_data_selected_editable_objects(const bContext *C, Vector< PointerRNA > *list)
eCustomDataMask CD_TYPE_AS_MASK(eCustomDataType type)
void RNA_enum_item_end(EnumPropertyItem **items, int *totitem)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
void RNA_def_property_enum_funcs_runtime(PropertyRNA *prop, EnumPropertyGetFunc getfunc, EnumPropertySetFunc setfunc, EnumPropertyItemFunc itemfunc, EnumPropertyGetTransformFunc get_transform_fn, EnumPropertySetTransformFunc set_transform_fn)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
Definition report.cc:191
const EnumPropertyItem rna_enum_dt_method_loop_items[]
Main * CTX_data_main(const bContext *C)
void RNA_enum_item_add_separator(EnumPropertyItem **items, int *totitem)
const char * CustomData_get_layer_name(const CustomData *data, eCustomDataType type, int n)
const EnumPropertyItem rna_enum_dt_layers_select_src_items[]
@ ID_RECALC_GEOMETRY
Definition DNA_ID.h:1074
@ PROP_SKIP_SAVE
Definition RNA_types.hh:414
@ PROP_HIDDEN
Definition RNA_types.hh:408
@ ID_TAG_DOIT
Definition DNA_ID.h:1029
void RNA_property_enum_set(PointerRNA *ptr, PropertyRNA *prop, int value)
const EnumPropertyItem rna_enum_dt_method_vertex_items[]
void DEG_relations_tag_update(Main *bmain)
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_UNDO
Definition WM_types.hh:190
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
@ PROP_FACTOR
Definition RNA_types.hh:308
@ PROP_DISTANCE
Definition RNA_types.hh:313
PropertyRNA * RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, const float default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
Mesh * BKE_object_get_evaluated_mesh_no_subsurf(const Object *object_eval)
Definition object.cc:4419
float RNA_float_get(PointerRNA *ptr, const char *name)
bool RNA_property_is_set(PointerRNA *ptr, PropertyRNA *prop)
char name[258]
Definition DNA_ID.h:433
CustomData corner_data
CustomData vert_data
struct bDeformGroup * next
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
bool(*) poll_property(const bContext *C, wmOperator *op, const PropertyRNA *prop) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1171
bool(*) check(bContext *C, wmOperator *op)
Definition WM_types.hh:1133
const char * description
Definition WM_types.hh:1115
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1141
std::string(*) get_description(bContext *C, wmOperatorType *ot, PointerRNA *ptr)
Definition WM_types.hh:1197
struct ReportList * reports
#define N_(msgid)