b3b2299f77fc2617f531e6703f3836bd6161c4c2
[blender.git] / source / blender / editors / object / object_data_transfer.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2014 by Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Bastien Montagne.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/object/object_data_transfer.c
29  *  \ingroup edobj
30  */
31
32 #include "DNA_mesh_types.h"
33 #include "DNA_modifier_types.h"
34 #include "DNA_object_types.h"
35 #include "DNA_scene_types.h"
36
37 #include "BLI_math.h"
38 #include "BLI_blenlib.h"
39 #include "BLI_utildefines.h"
40
41 #include "BKE_context.h"
42 #include "BKE_data_transfer.h"
43 #include "BKE_depsgraph.h"
44 #include "BKE_DerivedMesh.h"
45 #include "BKE_mesh_mapping.h"
46 #include "BKE_mesh_remap.h"
47 #include "BKE_object.h"
48 #include "BKE_report.h"
49
50 #include "RNA_access.h"
51 #include "RNA_define.h"
52 #include "RNA_enum_types.h"
53
54 #include "WM_api.h"
55 #include "WM_types.h"
56
57 #include "ED_object.h"
58
59 #include "UI_interface.h"
60
61 #include "object_intern.h"
62
63 /* All possible data to transfer.
64  * Note some are 'fake' ones, i.e. they are not hold by real CDLayers. */
65 /* Not shared with modifier, since we use a usual enum here, not a multi-choice one. */
66 static EnumPropertyItem DT_layer_items[] = {
67         {0, "", 0, "Vertex Data", ""},
68         {DT_TYPE_MDEFORMVERT, "VGROUP_WEIGHTS", 0, "Vertex Group(s)", "Transfer active or all vertex groups"},
69 #if 0  /* XXX For now, would like to finish/merge work from 2014 gsoc first. */
70         {DT_TYPE_SHAPEKEY, "SHAPEKEYS", 0, "Shapekey(s)", "Transfer active or all shape keys"},
71 #endif
72 #if 0  /* XXX When SkinModifier is enabled, it seems to erase its own CD_MVERT_SKIN layer from final DM :( */
73         {DT_TYPE_SKIN, "SKIN", 0, "Skin Weight", "Transfer skin weights"},
74 #endif
75         {DT_TYPE_BWEIGHT_VERT, "BEVEL_WEIGHT_VERT", 0, "Bevel Weight", "Transfer bevel weights"},
76         {0, "", 0, "Edge Data", ""},
77         {DT_TYPE_SHARP_EDGE, "SHARP_EDGE", 0, "Sharp", "Transfer sharp mark"},
78         {DT_TYPE_SEAM, "SEAM", 0, "UV Seam", "Transfer UV seam mark"},
79         {DT_TYPE_CREASE, "CREASE", 0, "Subsurf Crease", "Transfer crease values"},
80         {DT_TYPE_BWEIGHT_EDGE, "BEVEL_WEIGHT_EDGE", 0, "Bevel Weight", "Transfer bevel weights"},
81         {DT_TYPE_FREESTYLE_EDGE, "FREESTYLE_EDGE", 0, "Freestyle Mark", "Transfer Freestyle edge mark"},
82         {0, "", 0, "Face Corner Data", ""},
83         {DT_TYPE_LNOR, "CUSTOM_NORMAL", 0, "Custom Normals", "Transfer custom normals"},
84         {DT_TYPE_VCOL, "VCOL", 0, "VCol", "Vertex (face corners) colors"},
85         {DT_TYPE_UV, "UV", 0, "UVs", "Transfer UV layers"},
86         {0, "", 0, "Face Data", ""},
87         {DT_TYPE_SHARP_FACE, "SMOOTH", 0, "Smooth", "Transfer flat/smooth mark"},
88         {DT_TYPE_FREESTYLE_FACE, "FREESTYLE_FACE", 0, "Freestyle Mark", "Transfer Freestyle face mark"},
89         {0, NULL, 0, NULL, NULL}
90 };
91
92 /* Note: DT_layers_select_src_items enum is from rna_modifier.c */
93 static EnumPropertyItem *dt_layers_select_src_itemf(
94         bContext *C, PointerRNA *ptr, PropertyRNA *UNUSED(prop), bool *r_free)
95 {
96         EnumPropertyItem *item = NULL, tmp_item = {0};
97         int totitem = 0;
98
99         const int data_type = RNA_enum_get(ptr, "data_type");
100
101         if (!C) {  /* needed for docs and i18n tools */
102                 return DT_layers_select_src_items;
103         }
104
105         RNA_enum_items_add_value(&item, &totitem, DT_layers_select_src_items, DT_LAYERS_ACTIVE_SRC);
106         RNA_enum_items_add_value(&item, &totitem, DT_layers_select_src_items, DT_LAYERS_ALL_SRC);
107
108         if (data_type == DT_TYPE_MDEFORMVERT) {
109                 Object *ob_src = CTX_data_active_object(C);
110
111                 if (BKE_object_pose_armature_get(ob_src)) {
112                         RNA_enum_items_add_value(&item, &totitem, DT_layers_select_src_items, DT_LAYERS_VGROUP_SRC_BONE_SELECT);
113                         RNA_enum_items_add_value(&item, &totitem, DT_layers_select_src_items, DT_LAYERS_VGROUP_SRC_BONE_DEFORM);
114                 }
115
116                 if (ob_src) {
117                         bDeformGroup *dg;
118                         int i;
119
120                         RNA_enum_item_add_separator(&item, &totitem);
121
122                         for (i = 0, dg = ob_src->defbase.first; dg; i++, dg = dg->next) {
123                                 tmp_item.value = i;
124                                 tmp_item.identifier = tmp_item.name = dg->name;
125                                 RNA_enum_item_add(&item, &totitem, &tmp_item);
126                         }
127                 }
128         }
129         else if (data_type == DT_TYPE_SHAPEKEY) {
130                 /* TODO */
131         }
132         else if (data_type == DT_TYPE_UV) {
133                 Object *ob_src = CTX_data_active_object(C);
134                 Scene *scene = CTX_data_scene(C);
135
136                 if (ob_src) {
137                         DerivedMesh *dm_src;
138                         CustomData *pdata;
139                         int num_data, i;
140
141                         /* XXX Is this OK? */
142                         dm_src = mesh_get_derived_final(scene, ob_src, CD_MASK_BAREMESH | CD_MTEXPOLY);
143                         pdata = dm_src->getPolyDataLayout(dm_src);
144                         num_data = CustomData_number_of_layers(pdata, CD_MTEXPOLY);
145
146                         RNA_enum_item_add_separator(&item, &totitem);
147
148                         for (i = 0; i < num_data; i++) {
149                                 tmp_item.value = i;
150                                 tmp_item.identifier = tmp_item.name = CustomData_get_layer_name(pdata, CD_MTEXPOLY, i);
151                                 RNA_enum_item_add(&item, &totitem, &tmp_item);
152                         }
153                 }
154         }
155         else if (data_type == DT_TYPE_VCOL) {
156                 Object *ob_src = CTX_data_active_object(C);
157                 Scene *scene = CTX_data_scene(C);
158
159                 if (ob_src) {
160                         DerivedMesh *dm_src;
161                         CustomData *ldata;
162                         int num_data, i;
163
164                         /* XXX Is this OK? */
165                         dm_src = mesh_get_derived_final(scene, ob_src, CD_MASK_BAREMESH | CD_MLOOPCOL);
166                         ldata = dm_src->getLoopDataLayout(dm_src);
167                         num_data = CustomData_number_of_layers(ldata, CD_MLOOPCOL);
168
169                         RNA_enum_item_add_separator(&item, &totitem);
170
171                         for (i = 0; i < num_data; i++) {
172                                 tmp_item.value = i;
173                                 tmp_item.identifier = tmp_item.name = CustomData_get_layer_name(ldata, CD_MLOOPCOL, i);
174                                 RNA_enum_item_add(&item, &totitem, &tmp_item);
175                         }
176                 }
177         }
178
179         RNA_enum_item_end(&item, &totitem);
180         *r_free = true;
181
182         return item;
183 }
184
185 /* Note: DT_layers_select_dst_items enum is from rna_modifier.c */
186 static EnumPropertyItem *dt_layers_select_dst_itemf(bContext *C, PointerRNA *ptr, PropertyRNA *UNUSED(prop), bool *r_free)
187 {
188         EnumPropertyItem *item = NULL;
189         int totitem = 0;
190
191         const int layers_select_src = RNA_enum_get(ptr, "layers_select_src");
192
193         if (!C) {  /* needed for docs and i18n tools */
194                 return DT_layers_select_dst_items;
195         }
196
197         if (layers_select_src == DT_LAYERS_ACTIVE_SRC || layers_select_src >= 0) {
198                 RNA_enum_items_add_value(&item, &totitem, DT_layers_select_dst_items, DT_LAYERS_ACTIVE_DST);
199         }
200         RNA_enum_items_add_value(&item, &totitem, DT_layers_select_dst_items, DT_LAYERS_NAME_DST);
201         RNA_enum_items_add_value(&item, &totitem, DT_layers_select_dst_items, DT_LAYERS_INDEX_DST);
202
203         /* No 'specific' to-layers here, since we may transfer to several objects at once! */
204
205         RNA_enum_item_end(&item, &totitem);
206         *r_free = true;
207
208         return item;
209 }
210
211 /* Note: DT_mix_mode_items enum is from rna_modifier.c */
212 static EnumPropertyItem *dt_mix_mode_itemf(bContext *C, PointerRNA *ptr, PropertyRNA *UNUSED(prop), bool *r_free)
213 {
214         EnumPropertyItem *item = NULL;
215         int totitem = 0;
216
217         const int dtdata_type = RNA_enum_get(ptr, "data_type");
218         bool support_advanced_mixing, support_threshold;
219
220         if (!C) {  /* needed for docs and i18n tools */
221                 return DT_mix_mode_items;
222         }
223
224         RNA_enum_items_add_value(&item, &totitem, DT_mix_mode_items, CDT_MIX_TRANSFER);
225
226         BKE_object_data_transfer_get_dttypes_capacity(dtdata_type, &support_advanced_mixing, &support_threshold);
227
228         if (support_threshold) {
229                 RNA_enum_items_add_value(&item, &totitem, DT_mix_mode_items, CDT_MIX_REPLACE_ABOVE_THRESHOLD);
230                 RNA_enum_items_add_value(&item, &totitem, DT_mix_mode_items, CDT_MIX_REPLACE_BELOW_THRESHOLD);
231         }
232
233         if (support_advanced_mixing) {
234                 RNA_enum_item_add_separator(&item, &totitem);
235                 RNA_enum_items_add_value(&item, &totitem, DT_mix_mode_items, CDT_MIX_MIX);
236                 RNA_enum_items_add_value(&item, &totitem, DT_mix_mode_items, CDT_MIX_ADD);
237                 RNA_enum_items_add_value(&item, &totitem, DT_mix_mode_items, CDT_MIX_SUB);
238                 RNA_enum_items_add_value(&item, &totitem, DT_mix_mode_items, CDT_MIX_MUL);
239         }
240
241         RNA_enum_item_end(&item, &totitem);
242         *r_free = true;
243
244         return item;
245 }
246
247 static bool data_transfer_check(bContext *UNUSED(C), wmOperator *op)
248 {
249         const int layers_select_src = RNA_enum_get(op->ptr, "layers_select_src");
250         PropertyRNA *prop = RNA_struct_find_property(op->ptr, "layers_select_dst");
251         const int layers_select_dst = RNA_property_enum_get(op->ptr, prop);
252
253         /* TODO: check for invalid layers_src select modes too! */
254
255         if ((layers_select_src != DT_LAYERS_ACTIVE_SRC) && (layers_select_dst == DT_LAYERS_ACTIVE_DST)) {
256                 RNA_property_enum_set(op->ptr, prop, DT_LAYERS_NAME_DST);
257                 return true;
258         }
259
260         return false;
261 }
262
263 /* Helper, used by both data_transfer_exec and datalayout_transfer_exec. */
264 static void data_transfer_exec_preprocess_objects(
265         bContext *C, wmOperator *op, Object *ob_src, ListBase *ctx_objects, const bool reverse_transfer)
266 {
267         CollectionPointerLink *ctx_ob;
268         CTX_data_selected_editable_objects(C, ctx_objects);
269
270         if (reverse_transfer) {
271                 return;  /* Nothing else to do in this case... */
272         }
273
274         for (ctx_ob = ctx_objects->first; ctx_ob; ctx_ob = ctx_ob->next) {
275                 Object *ob = ctx_ob->ptr.data;
276                 Mesh *me;
277                 if ((ob == ob_src) || (ob->type != OB_MESH)) {
278                         continue;
279                 }
280
281                 me = ob->data;
282                 if (me->id.lib) {
283                         /* Do not transfer to linked data, not supported. */
284                         BKE_reportf(op->reports, RPT_WARNING, "Skipping object '%s', linked data '%s' cannot be modified",
285                                     ob->id.name + 2, me->id.name + 2);
286                         me->id.flag &= ~LIB_DOIT;
287                         continue;
288                 }
289
290                 me->id.flag |= LIB_DOIT;
291         }
292 }
293
294 /* Helper, used by both data_transfer_exec and datalayout_transfer_exec. */
295 static bool data_transfer_exec_is_object_valid(
296         wmOperator *op, Object *ob_src, Object *ob_dst, const bool reverse_transfer)
297 {
298         Mesh *me;
299         if ((ob_dst == ob_src) || (ob_src->type != OB_MESH) || (ob_dst->type != OB_MESH)) {
300                 return false;
301         }
302
303         if (reverse_transfer) {
304                 return true;
305         }
306
307         me = ob_dst->data;
308         if (me->id.flag & LIB_DOIT) {
309                 me->id.flag &= ~LIB_DOIT;
310                 return true;
311         }
312         else if (me->id.lib == NULL) {
313                 /* Do not transfer apply operation more than once. */
314                 /* XXX This is not nice regarding vgroups, which are half-Object data... :/ */
315                 BKE_reportf(op->reports, RPT_WARNING,
316                             "Skipping object '%s', data '%s' has already been processed with a previous object",
317                             ob_dst->id.name + 2, me->id.name + 2);
318         }
319         return false;
320 }
321
322 static int data_transfer_exec(bContext *C, wmOperator *op)
323 {
324         Scene *scene = CTX_data_scene(C);
325         Object *ob_src = ED_object_active_context(C);
326
327         ListBase ctx_objects;
328         CollectionPointerLink *ctx_ob_dst;
329
330         bool changed = false;
331
332         const bool reverse_transfer = RNA_boolean_get(op->ptr, "use_reverse_transfer");
333
334         const int data_type = RNA_enum_get(op->ptr, "data_type");
335         const bool use_create = RNA_boolean_get(op->ptr, "use_create");
336
337         const int map_vert_mode = RNA_enum_get(op->ptr, "vert_mapping");
338         const int map_edge_mode = RNA_enum_get(op->ptr, "edge_mapping");
339         const int map_loop_mode = RNA_enum_get(op->ptr, "loop_mapping");
340         const int map_poly_mode = RNA_enum_get(op->ptr, "poly_mapping");
341
342         const bool use_object_transform = RNA_boolean_get(op->ptr, "use_object_transform");
343         const bool use_max_distance = RNA_boolean_get(op->ptr, "use_max_distance");
344         const float max_distance = use_max_distance ? RNA_float_get(op->ptr, "max_distance") : FLT_MAX;
345         const float ray_radius = RNA_float_get(op->ptr, "ray_radius");
346         const float islands_precision = RNA_float_get(op->ptr, "islands_precision");
347
348         const int layers_src = RNA_enum_get(op->ptr, "layers_select_src");
349         const int layers_dst = RNA_enum_get(op->ptr, "layers_select_dst");
350         int layers_select_src[DT_MULTILAYER_INDEX_MAX] = {0};
351         int layers_select_dst[DT_MULTILAYER_INDEX_MAX] = {0};
352         const int fromto_idx = BKE_object_data_transfer_dttype_to_srcdst_index(data_type);
353
354         const int mix_mode = RNA_enum_get(op->ptr, "mix_mode");
355         const float mix_factor = RNA_float_get(op->ptr, "mix_factor");
356
357         SpaceTransform space_transform_data;
358         SpaceTransform *space_transform = use_object_transform ? &space_transform_data : NULL;
359
360         if (reverse_transfer && ((ID *)(ob_src->data))->lib) {
361                 /* Do not transfer to linked data, not supported. */
362                 return OPERATOR_CANCELLED;
363         }
364
365         if (fromto_idx != DT_MULTILAYER_INDEX_INVALID) {
366                 layers_select_src[fromto_idx] = layers_src;
367                 layers_select_dst[fromto_idx] = layers_dst;
368         }
369
370         data_transfer_exec_preprocess_objects(C, op, ob_src, &ctx_objects, reverse_transfer);
371
372         for (ctx_ob_dst = ctx_objects.first; ctx_ob_dst; ctx_ob_dst = ctx_ob_dst->next) {
373                 Object *ob_dst = ctx_ob_dst->ptr.data;
374
375                 if (reverse_transfer) {
376                         SWAP(Object *, ob_src, ob_dst);
377                 }
378
379                 if (data_transfer_exec_is_object_valid(op, ob_src, ob_dst, reverse_transfer)) {
380                         if (space_transform) {
381                                 BLI_SPACE_TRANSFORM_SETUP(space_transform, ob_dst, ob_src);
382                         }
383
384                         if (BKE_object_data_transfer_mesh(
385                                 scene, ob_src, ob_dst, data_type, use_create,
386                                 map_vert_mode, map_edge_mode, map_loop_mode, map_poly_mode,
387                                 space_transform, max_distance, ray_radius, islands_precision,
388                                 layers_select_src, layers_select_dst,
389                                 mix_mode, mix_factor, NULL, false, op->reports))
390                         {
391                                 changed = true;
392                         }
393                 }
394
395                 DAG_id_tag_update(&ob_dst->id, OB_RECALC_DATA);
396
397                 if (reverse_transfer) {
398                         SWAP(Object *, ob_src, ob_dst);
399                 }
400         }
401
402         BLI_freelistN(&ctx_objects);
403
404         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, NULL);
405
406 #if 0  /* TODO */
407         /* Note: issue with that is that if canceled, operator cannot be redone... Nasty in our case. */
408         return changed ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
409 #else
410         (void)changed;
411         return OPERATOR_FINISHED;
412 #endif
413 }
414
415 /* Used by both OBJECT_OT_data_transfer and OBJECT_OT_datalayout_transfer */
416 /* Note this context poll is only really partial, it cannot check for all possible invalid cases. */
417 static int data_transfer_poll(bContext *C)
418 {
419         Object *ob = ED_object_active_context(C);
420         ID *data = (ob) ? ob->data : NULL;
421         return (ob && ob->type == OB_MESH && data);
422 }
423
424 /* Used by both OBJECT_OT_data_transfer and OBJECT_OT_datalayout_transfer */
425 static bool data_transfer_draw_check_prop(PointerRNA *ptr, PropertyRNA *prop)
426 {
427         PropertyRNA *prop_other;
428
429         const char *prop_id = RNA_property_identifier(prop);
430         const int data_type = RNA_enum_get(ptr, "data_type");
431         bool use_max_distance = false;
432         bool use_modifier = false;
433
434         if ((prop_other = RNA_struct_find_property(ptr, "use_max_distance"))) {
435                 use_max_distance = RNA_property_boolean_get(ptr, prop_other);
436         }
437         if ((prop_other = RNA_struct_find_property(ptr, "modifier"))) {
438                 use_modifier = RNA_property_is_set(ptr, prop_other);
439         }
440
441         if (STREQ(prop_id, "modifier")) {
442                 return use_modifier;
443         }
444
445         if (use_modifier) {
446                 /* Hide everything but 'modifier' property, if set. */
447                 return false;
448         }
449
450         if (STREQ(prop_id, "max_distance") && !use_max_distance) {
451                 return false;
452         }
453         if (STREQ(prop_id, "islands_precision") && !DT_DATATYPE_IS_LOOP(data_type)) {
454                 return false;
455         }
456
457         if (STREQ(prop_id, "vert_mapping") && !DT_DATATYPE_IS_VERT(data_type)) {
458                 return false;
459         }
460         if (STREQ(prop_id, "edge_mapping") && !DT_DATATYPE_IS_EDGE(data_type)) {
461                 return false;
462         }
463         if (STREQ(prop_id, "loop_mapping") && !DT_DATATYPE_IS_LOOP(data_type)) {
464                 return false;
465         }
466         if (STREQ(prop_id, "poly_mapping") && !DT_DATATYPE_IS_POLY(data_type)) {
467                 return false;
468         }
469
470         if ((STREQ(prop_id, "layers_select_src") || STREQ(prop_id, "layers_select_dst")) &&
471             !DT_DATATYPE_IS_MULTILAYERS(data_type))
472         {
473                 return false;
474         }
475
476         /* Else, show it! */
477         return true;
478 }
479
480 /* Used by both OBJECT_OT_data_transfer and OBJECT_OT_datalayout_transfer */
481 static void data_transfer_ui(bContext *C, wmOperator *op)
482 {
483         uiLayout *layout = op->layout;
484         wmWindowManager *wm = CTX_wm_manager(C);
485         PointerRNA ptr;
486
487         RNA_pointer_create(&wm->id, op->type->srna, op->properties, &ptr);
488
489         /* Main auto-draw call */
490         uiDefAutoButsRNA(layout, &ptr, data_transfer_draw_check_prop, '\0');
491 }
492
493 /* transfers weight from active to selected */
494 void OBJECT_OT_data_transfer(wmOperatorType *ot)
495 {
496         PropertyRNA *prop;
497
498         /* Identifiers.*/
499         ot->name = "Transfer Mesh Data";
500         ot->idname = "OBJECT_OT_data_transfer";
501         ot->description = "Transfer data layer(s) (weights, edge sharp, ...) from active to selected meshes";
502
503         /* API callbacks.*/
504         ot->poll = data_transfer_poll;
505         ot->invoke = WM_menu_invoke;
506         ot->exec = data_transfer_exec;
507         ot->check = data_transfer_check;
508         ot->ui = data_transfer_ui;
509
510         /* Flags.*/
511         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
512
513         /* Properties.*/
514         prop = RNA_def_boolean(ot->srna, "use_reverse_transfer", false, "Reverse Transfer",
515                                "Transfer from selected objects to active one");
516         RNA_def_property_flag(prop, PROP_HIDDEN);
517
518         /* Data type to transfer. */
519         ot->prop = RNA_def_enum(ot->srna, "data_type", DT_layer_items, 0, "Data Type", "Which data to transfer");
520         RNA_def_boolean(ot->srna, "use_create", true, "Create Data", "Add data layers on destination meshes if needed");
521
522         /* Mapping methods. */
523         RNA_def_enum(ot->srna, "vert_mapping", DT_method_vertex_items, MREMAP_MODE_VERT_NEAREST, "Vertex Mapping",
524                      "Method used to map source vertices to destination ones");
525         RNA_def_enum(ot->srna, "edge_mapping", DT_method_edge_items, MREMAP_MODE_EDGE_NEAREST, "Edge Mapping",
526                      "Method used to map source edges to destination ones");
527         RNA_def_enum(ot->srna, "loop_mapping", DT_method_loop_items, MREMAP_MODE_LOOP_NEAREST_POLYNOR,
528                      "Face Corner Mapping", "Method used to map source faces' corners to destination ones");
529         RNA_def_enum(ot->srna, "poly_mapping", DT_method_poly_items, MREMAP_MODE_POLY_NEAREST, "Face Mapping",
530                      "Method used to map source faces to destination ones");
531
532         /* Mapping options and filtering. */
533         RNA_def_boolean(ot->srna, "use_object_transform", true, "Object Transform",
534                         "Evaluate source and destination meshes in their respective object spaces");
535         RNA_def_boolean(ot->srna, "use_max_distance", false, "Only Neighbor Geometry",
536                         "Source elements must be closer than given distance from destination one");
537         prop = RNA_def_float(ot->srna, "max_distance", 1.0f, 0.0f, FLT_MAX, "Max Distance",
538                              "Maximum allowed distance between source and destination element, for non-topology mappings",
539                              0.0f, 100.0f);
540         RNA_def_property_subtype(prop, PROP_DISTANCE);
541         prop = RNA_def_float(ot->srna, "ray_radius", 0.0f, 0.0f, FLT_MAX, "Ray Radius",
542                              "'Width' of rays (especially useful when raycasting against vertices or edges)",
543                              0.0f, 10.0f);
544         RNA_def_property_subtype(prop, PROP_DISTANCE);
545         prop = RNA_def_float(ot->srna, "islands_precision", 0.1f, 0.0f, 10.0f, "Islands Precision",
546                              "Factor controlling precision of islands handling (the higher, the better the results)",
547                              0.0f, 1.0f);
548         RNA_def_property_subtype(prop, PROP_FACTOR);
549
550         /* How to handle multi-layers types of data. */
551         prop = RNA_def_enum(ot->srna, "layers_select_src", DT_layers_select_src_items, DT_LAYERS_ACTIVE_SRC,
552                             "Source Layers Selection", "Which layers to transfer, in case of multi-layers types");
553         RNA_def_property_enum_funcs_runtime(prop, NULL, NULL, dt_layers_select_src_itemf);
554
555         prop = RNA_def_enum(ot->srna, "layers_select_dst", DT_layers_select_dst_items, DT_LAYERS_ACTIVE_DST,
556                             "Destination Layers Matching", "How to match source and destination layers");
557         RNA_def_property_enum_funcs_runtime(prop, NULL, NULL, dt_layers_select_dst_itemf);
558
559         prop = RNA_def_enum(ot->srna, "mix_mode", DT_mix_mode_items, CDT_MIX_TRANSFER, "Mix Mode",
560                            "How to affect destination elements with source values");
561         RNA_def_property_enum_funcs_runtime(prop, NULL, NULL, dt_mix_mode_itemf);
562         RNA_def_float(ot->srna, "mix_factor", 1.0f, 0.0f, 1.0f, "Mix Factor",
563                       "Factor to use when applying data to destination (exact behavior depends on mix mode)", 0.0f, 1.0f);
564 }
565
566 /******************************************************************************/
567 /* Note: This operator is hybrid, it can work as a usual standalone Object operator,
568  *       or as a DataTransfer modifier tool.
569  */
570
571 static int datalayout_transfer_poll(bContext *C)
572 {
573         return (edit_modifier_poll_generic(C, &RNA_DataTransferModifier, (1 << OB_MESH)) || data_transfer_poll(C));
574 }
575
576 static int datalayout_transfer_exec(bContext *C, wmOperator *op)
577 {
578         Scene *scene = CTX_data_scene(C);
579         Object *ob_act = ED_object_active_context(C);
580         DataTransferModifierData *dtmd;
581
582         dtmd = (DataTransferModifierData *)edit_modifier_property_get(op, ob_act, eModifierType_DataTransfer);
583
584         /* If we have a modifier, we transfer data layout from this modifier's source object to active one.
585          * Else, we transfer data layout from active object to all selected ones. */
586         if (dtmd) {
587                 Object *ob_src = dtmd->ob_source;
588                 Object *ob_dst = ob_act;
589
590                 const bool use_delete = false;  /* Never when used from modifier, for now. */
591
592                 if (!ob_src) {
593                         return OPERATOR_CANCELLED;
594                 }
595
596                 BKE_object_data_transfer_layout(scene, ob_src, ob_dst, dtmd->data_types, use_delete,
597                                                 dtmd->layers_select_src, dtmd->layers_select_dst);
598
599                 DAG_id_tag_update(&ob_dst->id, OB_RECALC_DATA);
600         }
601         else {
602                 Object *ob_src = ob_act;
603
604                 ListBase ctx_objects;
605                 CollectionPointerLink *ctx_ob_dst;
606
607                 const int data_type = RNA_enum_get(op->ptr, "data_type");
608                 const bool use_delete = RNA_boolean_get(op->ptr, "use_delete");
609
610                 const int layers_src = RNA_enum_get(op->ptr, "layers_select_src");
611                 const int layers_dst = RNA_enum_get(op->ptr, "layers_select_dst");
612                 int layers_select_src[DT_MULTILAYER_INDEX_MAX] = {0};
613                 int layers_select_dst[DT_MULTILAYER_INDEX_MAX] = {0};
614                 const int fromto_idx = BKE_object_data_transfer_dttype_to_srcdst_index(data_type);
615
616                 if (fromto_idx != DT_MULTILAYER_INDEX_INVALID) {
617                         layers_select_src[fromto_idx] = layers_src;
618                         layers_select_dst[fromto_idx] = layers_dst;
619                 }
620
621                 data_transfer_exec_preprocess_objects(C, op, ob_src, &ctx_objects, false);
622
623                 for (ctx_ob_dst = ctx_objects.first; ctx_ob_dst; ctx_ob_dst = ctx_ob_dst->next) {
624                         Object *ob_dst = ctx_ob_dst->ptr.data;
625                         if (data_transfer_exec_is_object_valid(op, ob_src, ob_dst, false)) {
626                                 BKE_object_data_transfer_layout(scene, ob_src, ob_dst, data_type, use_delete,
627                                                                 layers_select_src, layers_select_dst);
628                         }
629
630                         DAG_id_tag_update(&ob_dst->id, OB_RECALC_DATA);
631                 }
632
633                 BLI_freelistN(&ctx_objects);
634         }
635
636         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, NULL);
637
638         return OPERATOR_FINISHED;
639 }
640
641 static int datalayout_transfer_invoke(bContext *C, wmOperator *op, const wmEvent *event)
642 {
643         if (edit_modifier_invoke_properties(C, op)) {
644                 return datalayout_transfer_exec(C, op);
645         }
646         else {
647                 return WM_menu_invoke(C, op, event);
648         }
649 }
650
651 void OBJECT_OT_datalayout_transfer(wmOperatorType *ot)
652 {
653         PropertyRNA *prop;
654
655         ot->name = "Transfer Mesh Data Layout";
656         ot->description = "Transfer layout of data layer(s) from active to selected meshes";
657         ot->idname = "OBJECT_OT_datalayout_transfer";
658
659         ot->poll = datalayout_transfer_poll;
660         ot->invoke = datalayout_transfer_invoke;
661         ot->exec = datalayout_transfer_exec;
662         ot->check = data_transfer_check;
663         ot->ui = data_transfer_ui;
664
665         /* flags */
666         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
667
668         /* Properties.*/
669         edit_modifier_properties(ot);
670
671         /* Data type to transfer. */
672         ot->prop = RNA_def_enum(ot->srna, "data_type", DT_layer_items, 0, "Data Type", "Which data to transfer");
673         RNA_def_boolean(ot->srna, "use_delete", false, "Exact Match",
674                         "Also delete some data layers from destination if necessary, so that it matches exactly source");
675
676         /* How to handle multi-layers types of data. */
677         prop = RNA_def_enum(ot->srna, "layers_select_src", DT_layers_select_src_items, DT_LAYERS_ACTIVE_SRC,
678                             "Source Layers Selection", "Which layers to transfer, in case of multi-layers types");
679         RNA_def_property_enum_funcs_runtime(prop, NULL, NULL, dt_layers_select_src_itemf);
680
681         prop = RNA_def_enum(ot->srna, "layers_select_dst", DT_layers_select_dst_items, DT_LAYERS_ACTIVE_DST,
682                             "Destination Layers Matching", "How to match source and destination layers");
683         RNA_def_property_enum_funcs_runtime(prop, NULL, NULL, dt_layers_select_dst_itemf);
684 }