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