Cycles: Fix debug compilation after tile stealing commit
[blender.git] / source / blender / editors / object / object_data_transfer.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2014 by Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edobj
22  */
23
24 #include "DNA_mesh_types.h"
25 #include "DNA_modifier_types.h"
26 #include "DNA_object_types.h"
27 #include "DNA_scene_types.h"
28
29 #include "BLI_blenlib.h"
30 #include "BLI_math.h"
31 #include "BLI_utildefines.h"
32
33 #include "BKE_context.h"
34 #include "BKE_data_transfer.h"
35 #include "BKE_mesh_mapping.h"
36 #include "BKE_mesh_remap.h"
37 #include "BKE_mesh_runtime.h"
38 #include "BKE_object.h"
39 #include "BKE_report.h"
40
41 #include "DEG_depsgraph.h"
42 #include "DEG_depsgraph_query.h"
43
44 #include "RNA_access.h"
45 #include "RNA_define.h"
46 #include "RNA_enum_types.h"
47
48 #include "WM_api.h"
49 #include "WM_types.h"
50
51 #include "ED_object.h"
52
53 #include "UI_interface.h"
54
55 #include "object_intern.h"
56
57 /* All possible data to transfer.
58  * Note some are 'fake' ones, i.e. they are not hold by real CDLayers. */
59 /* Not shared with modifier, since we use a usual enum here, not a multi-choice one. */
60 static const EnumPropertyItem DT_layer_items[] = {
61     {0, "", 0, "Vertex Data", ""},
62     {DT_TYPE_MDEFORMVERT,
63      "VGROUP_WEIGHTS",
64      0,
65      "Vertex Group(s)",
66      "Transfer active or all vertex groups"},
67 #if 0 /* XXX For now, would like to finish/merge work from 2014 gsoc first. */
68     {DT_TYPE_SHAPEKEY, "SHAPEKEYS", 0, "Shapekey(s)", "Transfer active or all shape keys"},
69 #endif
70 /* XXX When SkinModifier is enabled,
71  * it seems to erase its own CD_MVERT_SKIN layer from final DM :( */
72 #if 0
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, "Subdivision Crease", "Transfer crease values"},
80     {DT_TYPE_BWEIGHT_EDGE, "BEVEL_WEIGHT_EDGE", 0, "Bevel Weight", "Transfer bevel weights"},
81     {DT_TYPE_FREESTYLE_EDGE,
82      "FREESTYLE_EDGE",
83      0,
84      "Freestyle Mark",
85      "Transfer Freestyle edge mark"},
86     {0, "", 0, "Face Corner Data", ""},
87     {DT_TYPE_LNOR, "CUSTOM_NORMAL", 0, "Custom Normals", "Transfer custom normals"},
88     {DT_TYPE_VCOL, "VCOL", 0, "Vertex Colors", "Vertex (face corners) colors"},
89     {DT_TYPE_UV, "UV", 0, "UVs", "Transfer UV layers"},
90     {0, "", 0, "Face Data", ""},
91     {DT_TYPE_SHARP_FACE, "SMOOTH", 0, "Smooth", "Transfer flat/smooth mark"},
92     {DT_TYPE_FREESTYLE_FACE,
93      "FREESTYLE_FACE",
94      0,
95      "Freestyle Mark",
96      "Transfer Freestyle face mark"},
97     {0, NULL, 0, NULL, NULL},
98 };
99
100 /* Note: rna_enum_dt_layers_select_src_items enum is from rna_modifier.c */
101 static const EnumPropertyItem *dt_layers_select_src_itemf(bContext *C,
102                                                           PointerRNA *ptr,
103                                                           PropertyRNA *UNUSED(prop),
104                                                           bool *r_free)
105 {
106   if (!C) { /* needed for docs and i18n tools */
107     return rna_enum_dt_layers_select_src_items;
108   }
109
110   EnumPropertyItem *item = NULL, tmp_item = {0};
111   int totitem = 0;
112   const int data_type = RNA_enum_get(ptr, "data_type");
113
114   PropertyRNA *prop = RNA_struct_find_property(ptr, "use_reverse_transfer");
115   const bool reverse_transfer = prop != NULL && RNA_property_boolean_get(ptr, prop);
116   const int layers_select_dst = reverse_transfer ? RNA_enum_get(ptr, "layers_select_src") :
117                                                    RNA_enum_get(ptr, "layers_select_dst");
118
119   if (!reverse_transfer || layers_select_dst == DT_LAYERS_ACTIVE_DST || layers_select_dst >= 0) {
120     RNA_enum_items_add_value(
121         &item, &totitem, rna_enum_dt_layers_select_src_items, DT_LAYERS_ACTIVE_SRC);
122   }
123   RNA_enum_items_add_value(
124       &item, &totitem, rna_enum_dt_layers_select_src_items, DT_LAYERS_ALL_SRC);
125
126   if (data_type == DT_TYPE_MDEFORMVERT) {
127     Object *ob_src = CTX_data_active_object(C);
128
129     if (BKE_object_pose_armature_get(ob_src)) {
130       RNA_enum_items_add_value(
131           &item, &totitem, rna_enum_dt_layers_select_src_items, DT_LAYERS_VGROUP_SRC_BONE_SELECT);
132       RNA_enum_items_add_value(
133           &item, &totitem, rna_enum_dt_layers_select_src_items, DT_LAYERS_VGROUP_SRC_BONE_DEFORM);
134     }
135
136     if (ob_src) {
137       bDeformGroup *dg;
138       int i;
139
140       RNA_enum_item_add_separator(&item, &totitem);
141
142       for (i = 0, dg = ob_src->defbase.first; dg; i++, dg = dg->next) {
143         tmp_item.value = i;
144         tmp_item.identifier = tmp_item.name = dg->name;
145         RNA_enum_item_add(&item, &totitem, &tmp_item);
146       }
147     }
148   }
149   else if (data_type == DT_TYPE_SHAPEKEY) {
150     /* TODO */
151   }
152   else if (data_type == DT_TYPE_UV) {
153     Object *ob_src = CTX_data_active_object(C);
154
155     if (ob_src) {
156       Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
157       Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
158       Object *ob_src_eval = DEG_get_evaluated_object(depsgraph, ob_src);
159
160       CustomData_MeshMasks cddata_masks = CD_MASK_BAREMESH;
161       cddata_masks.lmask |= CD_MASK_MLOOPUV;
162       Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_src_eval, &cddata_masks);
163       int num_data = CustomData_number_of_layers(&me_eval->ldata, CD_MLOOPUV);
164
165       RNA_enum_item_add_separator(&item, &totitem);
166
167       for (int i = 0; i < num_data; i++) {
168         tmp_item.value = i;
169         tmp_item.identifier = tmp_item.name = CustomData_get_layer_name(
170             &me_eval->ldata, CD_MLOOPUV, i);
171         RNA_enum_item_add(&item, &totitem, &tmp_item);
172       }
173     }
174   }
175   else if (data_type == DT_TYPE_VCOL) {
176     Object *ob_src = CTX_data_active_object(C);
177
178     if (ob_src) {
179       Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
180       Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
181       Object *ob_src_eval = DEG_get_evaluated_object(depsgraph, ob_src);
182
183       CustomData_MeshMasks cddata_masks = CD_MASK_BAREMESH;
184       cddata_masks.lmask |= CD_MASK_MLOOPCOL;
185       Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_src_eval, &cddata_masks);
186       int num_data = CustomData_number_of_layers(&me_eval->ldata, CD_MLOOPCOL);
187
188       RNA_enum_item_add_separator(&item, &totitem);
189
190       for (int i = 0; i < num_data; i++) {
191         tmp_item.value = i;
192         tmp_item.identifier = tmp_item.name = CustomData_get_layer_name(
193             &me_eval->ldata, CD_MLOOPCOL, i);
194         RNA_enum_item_add(&item, &totitem, &tmp_item);
195       }
196     }
197   }
198
199   RNA_enum_item_end(&item, &totitem);
200   *r_free = true;
201
202   return item;
203 }
204
205 /* Note: rna_enum_dt_layers_select_dst_items enum is from rna_modifier.c */
206 static const EnumPropertyItem *dt_layers_select_dst_itemf(bContext *C,
207                                                           PointerRNA *ptr,
208                                                           PropertyRNA *UNUSED(prop),
209                                                           bool *r_free)
210 {
211   if (!C) { /* needed for docs and i18n tools */
212     return rna_enum_dt_layers_select_dst_items;
213   }
214
215   EnumPropertyItem *item = NULL;
216   int totitem = 0;
217
218   PropertyRNA *prop = RNA_struct_find_property(ptr, "use_reverse_transfer");
219   const bool reverse_transfer = prop != NULL && RNA_property_boolean_get(ptr, prop);
220   const int layers_select_src = reverse_transfer ? RNA_enum_get(ptr, "layers_select_dst") :
221                                                    RNA_enum_get(ptr, "layers_select_src");
222
223   if (reverse_transfer || layers_select_src == DT_LAYERS_ACTIVE_SRC || layers_select_src >= 0) {
224     RNA_enum_items_add_value(
225         &item, &totitem, rna_enum_dt_layers_select_dst_items, DT_LAYERS_ACTIVE_DST);
226   }
227   RNA_enum_items_add_value(
228       &item, &totitem, rna_enum_dt_layers_select_dst_items, DT_LAYERS_NAME_DST);
229   RNA_enum_items_add_value(
230       &item, &totitem, rna_enum_dt_layers_select_dst_items, DT_LAYERS_INDEX_DST);
231
232   /* No 'specific' to-layers here, since we may transfer to several objects at once! */
233
234   RNA_enum_item_end(&item, &totitem);
235   *r_free = true;
236
237   return item;
238 }
239
240 static const EnumPropertyItem *dt_layers_select_itemf(bContext *C,
241                                                       PointerRNA *ptr,
242                                                       PropertyRNA *prop,
243                                                       bool *r_free)
244 {
245   const bool reverse_transfer = RNA_boolean_get(ptr, "use_reverse_transfer");
246
247   if (STREQ(RNA_property_identifier(prop), "layers_select_dst")) {
248     if (reverse_transfer) {
249       return dt_layers_select_src_itemf(C, ptr, prop, r_free);
250     }
251     return dt_layers_select_dst_itemf(C, ptr, prop, r_free);
252   }
253   if (reverse_transfer) {
254     return dt_layers_select_dst_itemf(C, ptr, prop, r_free);
255   }
256   return dt_layers_select_src_itemf(C, ptr, prop, r_free);
257 }
258
259 /* Note: rna_enum_dt_mix_mode_items enum is from rna_modifier.c */
260 static const EnumPropertyItem *dt_mix_mode_itemf(bContext *C,
261                                                  PointerRNA *ptr,
262                                                  PropertyRNA *UNUSED(prop),
263                                                  bool *r_free)
264 {
265   EnumPropertyItem *item = NULL;
266   int totitem = 0;
267
268   const int dtdata_type = RNA_enum_get(ptr, "data_type");
269   bool support_advanced_mixing, support_threshold;
270
271   if (!C) { /* needed for docs and i18n tools */
272     return rna_enum_dt_mix_mode_items;
273   }
274
275   RNA_enum_items_add_value(&item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_TRANSFER);
276
277   BKE_object_data_transfer_get_dttypes_capacity(
278       dtdata_type, &support_advanced_mixing, &support_threshold);
279
280   if (support_threshold) {
281     RNA_enum_items_add_value(
282         &item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_REPLACE_ABOVE_THRESHOLD);
283     RNA_enum_items_add_value(
284         &item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_REPLACE_BELOW_THRESHOLD);
285   }
286
287   if (support_advanced_mixing) {
288     RNA_enum_item_add_separator(&item, &totitem);
289     RNA_enum_items_add_value(&item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_MIX);
290     RNA_enum_items_add_value(&item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_ADD);
291     RNA_enum_items_add_value(&item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_SUB);
292     RNA_enum_items_add_value(&item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_MUL);
293   }
294
295   RNA_enum_item_end(&item, &totitem);
296   *r_free = true;
297
298   return item;
299 }
300
301 static bool data_transfer_check(bContext *UNUSED(C), wmOperator *op)
302 {
303   const int layers_select_src = RNA_enum_get(op->ptr, "layers_select_src");
304   PropertyRNA *prop = RNA_struct_find_property(op->ptr, "layers_select_dst");
305   const int layers_select_dst = RNA_property_enum_get(op->ptr, prop);
306
307   /* TODO: check for invalid layers_src select modes too! */
308
309   if ((layers_select_src != DT_LAYERS_ACTIVE_SRC) && (layers_select_dst == DT_LAYERS_ACTIVE_DST)) {
310     RNA_property_enum_set(op->ptr, prop, DT_LAYERS_NAME_DST);
311     return true;
312   }
313
314   return false;
315 }
316
317 /* Helper, used by both data_transfer_exec and datalayout_transfer_exec. */
318 static void data_transfer_exec_preprocess_objects(bContext *C,
319                                                   wmOperator *op,
320                                                   Object *ob_src,
321                                                   ListBase *ctx_objects,
322                                                   const bool reverse_transfer)
323 {
324   CollectionPointerLink *ctx_ob;
325   CTX_data_selected_editable_objects(C, ctx_objects);
326
327   if (reverse_transfer) {
328     return; /* Nothing else to do in this case... */
329   }
330
331   for (ctx_ob = ctx_objects->first; ctx_ob; ctx_ob = ctx_ob->next) {
332     Object *ob = ctx_ob->ptr.data;
333     Mesh *me;
334     if ((ob == ob_src) || (ob->type != OB_MESH)) {
335       continue;
336     }
337
338     me = ob->data;
339     if (ID_IS_LINKED(me)) {
340       /* Do not transfer to linked data, not supported. */
341       BKE_reportf(op->reports,
342                   RPT_WARNING,
343                   "Skipping object '%s', linked data '%s' cannot be modified",
344                   ob->id.name + 2,
345                   me->id.name + 2);
346       me->id.tag &= ~LIB_TAG_DOIT;
347       continue;
348     }
349
350     me->id.tag |= LIB_TAG_DOIT;
351   }
352 }
353
354 /* Helper, used by both data_transfer_exec and datalayout_transfer_exec. */
355 static bool data_transfer_exec_is_object_valid(wmOperator *op,
356                                                Object *ob_src,
357                                                Object *ob_dst,
358                                                const bool reverse_transfer)
359 {
360   Mesh *me;
361   if ((ob_dst == ob_src) || (ob_src->type != OB_MESH) || (ob_dst->type != OB_MESH)) {
362     return false;
363   }
364
365   if (reverse_transfer) {
366     return true;
367   }
368
369   me = ob_dst->data;
370   if (me->id.tag & LIB_TAG_DOIT) {
371     me->id.tag &= ~LIB_TAG_DOIT;
372     return true;
373   }
374   if (!ID_IS_LINKED(me) && !ID_IS_OVERRIDE_LIBRARY(me)) {
375     /* Do not apply transfer operation more than once. */
376     /* XXX This is not nice regarding vgroups, which are half-Object data... :/ */
377     BKE_reportf(
378         op->reports,
379         RPT_WARNING,
380         "Skipping object '%s', data '%s' has already been processed with a previous object",
381         ob_dst->id.name + 2,
382         me->id.name + 2);
383   }
384   return false;
385 }
386
387 static int data_transfer_exec(bContext *C, wmOperator *op)
388 {
389   Object *ob_src = ED_object_active_context(C);
390   Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
391   Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
392
393   ListBase ctx_objects;
394   CollectionPointerLink *ctx_ob_dst;
395
396   bool changed = false;
397
398   const bool is_frozen = RNA_boolean_get(op->ptr, "use_freeze");
399
400   const bool reverse_transfer = RNA_boolean_get(op->ptr, "use_reverse_transfer");
401
402   const int data_type = RNA_enum_get(op->ptr, "data_type");
403   const bool use_create = RNA_boolean_get(op->ptr, "use_create");
404
405   const int map_vert_mode = RNA_enum_get(op->ptr, "vert_mapping");
406   const int map_edge_mode = RNA_enum_get(op->ptr, "edge_mapping");
407   const int map_loop_mode = RNA_enum_get(op->ptr, "loop_mapping");
408   const int map_poly_mode = RNA_enum_get(op->ptr, "poly_mapping");
409
410   const bool use_auto_transform = RNA_boolean_get(op->ptr, "use_auto_transform");
411   const bool use_object_transform = RNA_boolean_get(op->ptr, "use_object_transform");
412   const bool use_max_distance = RNA_boolean_get(op->ptr, "use_max_distance");
413   const float max_distance = use_max_distance ? RNA_float_get(op->ptr, "max_distance") : FLT_MAX;
414   const float ray_radius = RNA_float_get(op->ptr, "ray_radius");
415   const float islands_precision = RNA_float_get(op->ptr, "islands_precision");
416
417   int layers_src = RNA_enum_get(op->ptr, "layers_select_src");
418   int layers_dst = RNA_enum_get(op->ptr, "layers_select_dst");
419   int layers_select_src[DT_MULTILAYER_INDEX_MAX] = {0};
420   int layers_select_dst[DT_MULTILAYER_INDEX_MAX] = {0};
421   const int fromto_idx = BKE_object_data_transfer_dttype_to_srcdst_index(data_type);
422
423   const int mix_mode = RNA_enum_get(op->ptr, "mix_mode");
424   const float mix_factor = RNA_float_get(op->ptr, "mix_factor");
425
426   SpaceTransform space_transform_data;
427   SpaceTransform *space_transform = (use_object_transform && !use_auto_transform) ?
428                                         &space_transform_data :
429                                         NULL;
430
431   if (is_frozen) {
432     BKE_report(
433         op->reports,
434         RPT_INFO,
435         "Operator is frozen, changes to its settings won't take effect until you unfreeze it");
436     return OPERATOR_FINISHED;
437   }
438
439   if (reverse_transfer && (ID_IS_LINKED(ob_src->data) || ID_IS_OVERRIDE_LIBRARY(ob_src->data))) {
440     /* Do not transfer to linked or override data, not supported. */
441     return OPERATOR_CANCELLED;
442   }
443
444   if (reverse_transfer) {
445     SWAP(int, layers_src, layers_dst);
446   }
447
448   if (fromto_idx != DT_MULTILAYER_INDEX_INVALID) {
449     layers_select_src[fromto_idx] = layers_src;
450     layers_select_dst[fromto_idx] = layers_dst;
451   }
452
453   data_transfer_exec_preprocess_objects(C, op, ob_src, &ctx_objects, reverse_transfer);
454
455   for (ctx_ob_dst = ctx_objects.first; ctx_ob_dst; ctx_ob_dst = ctx_ob_dst->next) {
456     Object *ob_dst = ctx_ob_dst->ptr.data;
457
458     if (reverse_transfer) {
459       SWAP(Object *, ob_src, ob_dst);
460     }
461
462     if (data_transfer_exec_is_object_valid(op, ob_src, ob_dst, reverse_transfer)) {
463       Object *ob_src_eval = DEG_get_evaluated_object(depsgraph, ob_src);
464
465       if (space_transform) {
466         Object *ob_dst_eval = DEG_get_evaluated_object(depsgraph, ob_dst);
467         BLI_SPACE_TRANSFORM_SETUP(space_transform, ob_dst_eval, ob_src_eval);
468       }
469
470       if (BKE_object_data_transfer_mesh(depsgraph,
471                                         scene_eval,
472                                         ob_src_eval,
473                                         ob_dst,
474                                         data_type,
475                                         use_create,
476                                         map_vert_mode,
477                                         map_edge_mode,
478                                         map_loop_mode,
479                                         map_poly_mode,
480                                         space_transform,
481                                         use_auto_transform,
482                                         max_distance,
483                                         ray_radius,
484                                         islands_precision,
485                                         layers_select_src,
486                                         layers_select_dst,
487                                         mix_mode,
488                                         mix_factor,
489                                         NULL,
490                                         false,
491                                         op->reports)) {
492
493         if (data_type == DT_TYPE_LNOR && use_create) {
494           ((Mesh *)ob_dst->data)->flag |= ME_AUTOSMOOTH;
495         }
496
497         DEG_id_tag_update(&ob_dst->id, ID_RECALC_GEOMETRY);
498         changed = true;
499       }
500     }
501
502     if (reverse_transfer) {
503       SWAP(Object *, ob_src, ob_dst);
504     }
505   }
506
507   BLI_freelistN(&ctx_objects);
508
509   if (changed) {
510     DEG_relations_tag_update(CTX_data_main(C));
511     WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, NULL);
512   }
513
514 #if 0 /* TODO */
515   /* Note: issue with that is that if canceled, operator cannot be redone... Nasty in our case. */
516   return changed ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
517 #else
518   return OPERATOR_FINISHED;
519 #endif
520 }
521
522 /* Used by both OBJECT_OT_data_transfer and OBJECT_OT_datalayout_transfer */
523 /* Note this context poll is only really partial,
524  * it cannot check for all possible invalid cases. */
525 static bool data_transfer_poll(bContext *C)
526 {
527   Object *ob = ED_object_active_context(C);
528   ID *data = (ob) ? ob->data : NULL;
529   return (ob != NULL && ob->type == OB_MESH && data != NULL);
530 }
531
532 /* Used by both OBJECT_OT_data_transfer and OBJECT_OT_datalayout_transfer */
533 static bool data_transfer_poll_property(const bContext *UNUSED(C),
534                                         wmOperator *op,
535                                         const PropertyRNA *prop)
536 {
537   PointerRNA *ptr = op->ptr;
538   PropertyRNA *prop_other;
539
540   const char *prop_id = RNA_property_identifier(prop);
541   const int data_type = RNA_enum_get(ptr, "data_type");
542   bool use_auto_transform = false;
543   bool use_max_distance = false;
544   bool use_modifier = false;
545
546   if ((prop_other = RNA_struct_find_property(ptr, "use_auto_transform"))) {
547     use_auto_transform = RNA_property_boolean_get(ptr, prop_other);
548   }
549   if ((prop_other = RNA_struct_find_property(ptr, "use_max_distance"))) {
550     use_max_distance = RNA_property_boolean_get(ptr, prop_other);
551   }
552   if ((prop_other = RNA_struct_find_property(ptr, "modifier"))) {
553     use_modifier = RNA_property_is_set(ptr, prop_other);
554   }
555
556   if (STREQ(prop_id, "modifier")) {
557     return use_modifier;
558   }
559
560   if (use_modifier) {
561     /* Hide everything but 'modifier' property, if set. */
562     return false;
563   }
564
565   if (STREQ(prop_id, "use_object_transform") && use_auto_transform) {
566     return false;
567   }
568   if (STREQ(prop_id, "max_distance") && !use_max_distance) {
569     return false;
570   }
571   if (STREQ(prop_id, "islands_precision") && !DT_DATATYPE_IS_LOOP(data_type)) {
572     return false;
573   }
574
575   if (STREQ(prop_id, "vert_mapping") && !DT_DATATYPE_IS_VERT(data_type)) {
576     return false;
577   }
578   if (STREQ(prop_id, "edge_mapping") && !DT_DATATYPE_IS_EDGE(data_type)) {
579     return false;
580   }
581   if (STREQ(prop_id, "loop_mapping") && !DT_DATATYPE_IS_LOOP(data_type)) {
582     return false;
583   }
584   if (STREQ(prop_id, "poly_mapping") && !DT_DATATYPE_IS_POLY(data_type)) {
585     return false;
586   }
587
588   if ((STREQ(prop_id, "layers_select_src") || STREQ(prop_id, "layers_select_dst")) &&
589       !DT_DATATYPE_IS_MULTILAYERS(data_type)) {
590     return false;
591   }
592
593   /* Else, show it! */
594   return true;
595 }
596
597 /* Transfer mesh data from active to selected objects. */
598 void OBJECT_OT_data_transfer(wmOperatorType *ot)
599 {
600   PropertyRNA *prop;
601
602   /* Identifiers.*/
603   ot->name = "Transfer Mesh Data";
604   ot->idname = "OBJECT_OT_data_transfer";
605   ot->description =
606       "Transfer data layer(s) (weights, edge sharp, ...) from active to selected meshes";
607
608   /* API callbacks.*/
609   ot->poll = data_transfer_poll;
610   ot->poll_property = data_transfer_poll_property;
611   ot->invoke = WM_menu_invoke;
612   ot->exec = data_transfer_exec;
613   ot->check = data_transfer_check;
614
615   /* Flags.*/
616   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
617
618   /* Properties.*/
619   prop = RNA_def_boolean(ot->srna,
620                          "use_reverse_transfer",
621                          false,
622                          "Reverse Transfer",
623                          "Transfer from selected objects to active one");
624   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
625
626   RNA_def_boolean(ot->srna,
627                   "use_freeze",
628                   false,
629                   "Freeze Operator",
630                   "Prevent changes to settings to re-run the operator, "
631                   "handy to change several things at once with heavy geometry");
632
633   /* Data type to transfer. */
634   ot->prop = RNA_def_enum(
635       ot->srna, "data_type", DT_layer_items, 0, "Data Type", "Which data to transfer");
636   RNA_def_boolean(ot->srna,
637                   "use_create",
638                   true,
639                   "Create Data",
640                   "Add data layers on destination meshes if needed");
641
642   /* Mapping methods. */
643   RNA_def_enum(ot->srna,
644                "vert_mapping",
645                rna_enum_dt_method_vertex_items,
646                MREMAP_MODE_VERT_NEAREST,
647                "Vertex Mapping",
648                "Method used to map source vertices to destination ones");
649   RNA_def_enum(ot->srna,
650                "edge_mapping",
651                rna_enum_dt_method_edge_items,
652                MREMAP_MODE_EDGE_NEAREST,
653                "Edge Mapping",
654                "Method used to map source edges to destination ones");
655   RNA_def_enum(ot->srna,
656                "loop_mapping",
657                rna_enum_dt_method_loop_items,
658                MREMAP_MODE_LOOP_NEAREST_POLYNOR,
659                "Face Corner Mapping",
660                "Method used to map source faces' corners to destination ones");
661   RNA_def_enum(ot->srna,
662                "poly_mapping",
663                rna_enum_dt_method_poly_items,
664                MREMAP_MODE_POLY_NEAREST,
665                "Face Mapping",
666                "Method used to map source faces to destination ones");
667
668   /* Mapping options and filtering. */
669   RNA_def_boolean(
670       ot->srna,
671       "use_auto_transform",
672       false,
673       "Auto Transform",
674       "Automatically compute transformation to get the best possible match between source and "
675       "destination meshes (WARNING: results will never be as good as manual matching of objects)");
676   RNA_def_boolean(ot->srna,
677                   "use_object_transform",
678                   true,
679                   "Object Transform",
680                   "Evaluate source and destination meshes in global space");
681   RNA_def_boolean(ot->srna,
682                   "use_max_distance",
683                   false,
684                   "Only Neighbor Geometry",
685                   "Source elements must be closer than given distance from destination one");
686   prop = RNA_def_float(
687       ot->srna,
688       "max_distance",
689       1.0f,
690       0.0f,
691       FLT_MAX,
692       "Max Distance",
693       "Maximum allowed distance between source and destination element, for non-topology mappings",
694       0.0f,
695       100.0f);
696   RNA_def_property_subtype(prop, PROP_DISTANCE);
697   prop = RNA_def_float(
698       ot->srna,
699       "ray_radius",
700       0.0f,
701       0.0f,
702       FLT_MAX,
703       "Ray Radius",
704       "'Width' of rays (especially useful when raycasting against vertices or edges)",
705       0.0f,
706       10.0f);
707   RNA_def_property_subtype(prop, PROP_DISTANCE);
708   prop = RNA_def_float(
709       ot->srna,
710       "islands_precision",
711       0.1f,
712       0.0f,
713       10.0f,
714       "Islands Precision",
715       "Factor controlling precision of islands handling (the higher, the better the results)",
716       0.0f,
717       1.0f);
718   RNA_def_property_subtype(prop, PROP_FACTOR);
719
720   /* How to handle multi-layers types of data. */
721   prop = RNA_def_enum(ot->srna,
722                       "layers_select_src",
723                       rna_enum_dt_layers_select_src_items,
724                       DT_LAYERS_ACTIVE_SRC,
725                       "Source Layers Selection",
726                       "Which layers to transfer, in case of multi-layers types");
727   RNA_def_property_enum_funcs_runtime(prop, NULL, NULL, dt_layers_select_itemf);
728
729   prop = RNA_def_enum(ot->srna,
730                       "layers_select_dst",
731                       rna_enum_dt_layers_select_dst_items,
732                       DT_LAYERS_ACTIVE_DST,
733                       "Destination Layers Matching",
734                       "How to match source and destination layers");
735   RNA_def_property_enum_funcs_runtime(prop, NULL, NULL, dt_layers_select_itemf);
736
737   prop = RNA_def_enum(ot->srna,
738                       "mix_mode",
739                       rna_enum_dt_mix_mode_items,
740                       CDT_MIX_TRANSFER,
741                       "Mix Mode",
742                       "How to affect destination elements with source values");
743   RNA_def_property_enum_funcs_runtime(prop, NULL, NULL, dt_mix_mode_itemf);
744   RNA_def_float(
745       ot->srna,
746       "mix_factor",
747       1.0f,
748       0.0f,
749       1.0f,
750       "Mix Factor",
751       "Factor to use when applying data to destination (exact behavior depends on mix mode)",
752       0.0f,
753       1.0f);
754 }
755
756 /******************************************************************************/
757 /* Note: This operator is hybrid, it can work as a usual standalone Object operator,
758  *       or as a DataTransfer modifier tool.
759  */
760
761 static bool datalayout_transfer_poll(bContext *C)
762 {
763   return (edit_modifier_poll_generic(C, &RNA_DataTransferModifier, (1 << OB_MESH), true, false) ||
764           data_transfer_poll(C));
765 }
766
767 static int datalayout_transfer_exec(bContext *C, wmOperator *op)
768 {
769   Object *ob_act = ED_object_active_context(C);
770   Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
771   Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
772   DataTransferModifierData *dtmd;
773
774   dtmd = (DataTransferModifierData *)edit_modifier_property_get(
775       op, ob_act, eModifierType_DataTransfer);
776
777   /* If we have a modifier, we transfer data layout from this modifier's source object to
778    * active one. Else, we transfer data layout from active object to all selected ones. */
779   if (dtmd) {
780     Object *ob_src = dtmd->ob_source;
781     Object *ob_dst = ob_act;
782
783     const bool use_delete = false; /* Never when used from modifier, for now. */
784
785     if (!ob_src || ID_IS_LINKED(ob_dst) || ID_IS_OVERRIDE_LIBRARY(ob_dst)) {
786       return OPERATOR_CANCELLED;
787     }
788
789     Object *ob_src_eval = DEG_get_evaluated_object(depsgraph, ob_src);
790
791     BKE_object_data_transfer_layout(depsgraph,
792                                     scene_eval,
793                                     ob_src_eval,
794                                     ob_dst,
795                                     dtmd->data_types,
796                                     use_delete,
797                                     dtmd->layers_select_src,
798                                     dtmd->layers_select_dst);
799
800     DEG_id_tag_update(&ob_dst->id, ID_RECALC_GEOMETRY);
801   }
802   else {
803     Object *ob_src = ob_act;
804
805     ListBase ctx_objects;
806     CollectionPointerLink *ctx_ob_dst;
807
808     const int data_type = RNA_enum_get(op->ptr, "data_type");
809     const bool use_delete = RNA_boolean_get(op->ptr, "use_delete");
810
811     const int layers_src = RNA_enum_get(op->ptr, "layers_select_src");
812     const int layers_dst = RNA_enum_get(op->ptr, "layers_select_dst");
813     int layers_select_src[DT_MULTILAYER_INDEX_MAX] = {0};
814     int layers_select_dst[DT_MULTILAYER_INDEX_MAX] = {0};
815     const int fromto_idx = BKE_object_data_transfer_dttype_to_srcdst_index(data_type);
816
817     if (fromto_idx != DT_MULTILAYER_INDEX_INVALID) {
818       layers_select_src[fromto_idx] = layers_src;
819       layers_select_dst[fromto_idx] = layers_dst;
820     }
821
822     Object *ob_src_eval = DEG_get_evaluated_object(depsgraph, ob_src);
823
824     data_transfer_exec_preprocess_objects(C, op, ob_src, &ctx_objects, false);
825
826     for (ctx_ob_dst = ctx_objects.first; ctx_ob_dst; ctx_ob_dst = ctx_ob_dst->next) {
827       Object *ob_dst = ctx_ob_dst->ptr.data;
828       if (data_transfer_exec_is_object_valid(op, ob_src, ob_dst, false)) {
829         BKE_object_data_transfer_layout(depsgraph,
830                                         scene_eval,
831                                         ob_src_eval,
832                                         ob_dst,
833                                         data_type,
834                                         use_delete,
835                                         layers_select_src,
836                                         layers_select_dst);
837       }
838
839       DEG_id_tag_update(&ob_dst->id, ID_RECALC_GEOMETRY);
840     }
841
842     BLI_freelistN(&ctx_objects);
843   }
844
845   DEG_relations_tag_update(CTX_data_main(C));
846   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, NULL);
847
848   return OPERATOR_FINISHED;
849 }
850
851 static int datalayout_transfer_invoke(bContext *C, wmOperator *op, const wmEvent *event)
852 {
853   if (edit_modifier_invoke_properties(C, op, NULL, NULL)) {
854     return datalayout_transfer_exec(C, op);
855   }
856   return WM_menu_invoke(C, op, event);
857 }
858
859 void OBJECT_OT_datalayout_transfer(wmOperatorType *ot)
860 {
861   PropertyRNA *prop;
862
863   ot->name = "Transfer Mesh Data Layout";
864   ot->description = "Transfer layout of data layer(s) from active to selected meshes";
865   ot->idname = "OBJECT_OT_datalayout_transfer";
866
867   ot->poll = datalayout_transfer_poll;
868   ot->poll_property = data_transfer_poll_property;
869   ot->invoke = datalayout_transfer_invoke;
870   ot->exec = datalayout_transfer_exec;
871   ot->check = data_transfer_check;
872
873   /* flags */
874   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
875
876   /* Properties.*/
877   edit_modifier_properties(ot);
878
879   /* Data type to transfer. */
880   ot->prop = RNA_def_enum(
881       ot->srna, "data_type", DT_layer_items, 0, "Data Type", "Which data to transfer");
882   RNA_def_boolean(ot->srna,
883                   "use_delete",
884                   false,
885                   "Exact Match",
886                   "Also delete some data layers from destination if necessary, so that it matches "
887                   "exactly source");
888
889   /* How to handle multi-layers types of data. */
890   prop = RNA_def_enum(ot->srna,
891                       "layers_select_src",
892                       rna_enum_dt_layers_select_src_items,
893                       DT_LAYERS_ACTIVE_SRC,
894                       "Source Layers Selection",
895                       "Which layers to transfer, in case of multi-layers types");
896   RNA_def_property_enum_funcs_runtime(prop, NULL, NULL, dt_layers_select_src_itemf);
897
898   prop = RNA_def_enum(ot->srna,
899                       "layers_select_dst",
900                       rna_enum_dt_layers_select_dst_items,
901                       DT_LAYERS_ACTIVE_DST,
902                       "Destination Layers Matching",
903                       "How to match source and destination layers");
904   RNA_def_property_enum_funcs_runtime(prop, NULL, NULL, dt_layers_select_dst_itemf);
905 }