UI: Add shortcuts for grease pencil modifier panels
[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, "VCol", "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       Mesh *me_eval;
157       int num_data, i;
158
159       Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
160       Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
161       Object *ob_src_eval = DEG_get_evaluated_object(depsgraph, ob_src);
162
163       CustomData_MeshMasks cddata_masks = CD_MASK_BAREMESH;
164       cddata_masks.lmask |= CD_MASK_MLOOPUV;
165       me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_src_eval, &cddata_masks);
166       num_data = CustomData_number_of_layers(&me_eval->ldata, CD_MLOOPUV);
167
168       RNA_enum_item_add_separator(&item, &totitem);
169
170       for (i = 0; i < num_data; i++) {
171         tmp_item.value = i;
172         tmp_item.identifier = tmp_item.name = CustomData_get_layer_name(
173             &me_eval->ldata, CD_MLOOPUV, i);
174         RNA_enum_item_add(&item, &totitem, &tmp_item);
175       }
176     }
177   }
178   else if (data_type == DT_TYPE_VCOL) {
179     Object *ob_src = CTX_data_active_object(C);
180
181     if (ob_src) {
182       Mesh *me_eval;
183       int num_data, i;
184
185       Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
186       Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
187       Object *ob_src_eval = DEG_get_evaluated_object(depsgraph, ob_src);
188
189       CustomData_MeshMasks cddata_masks = CD_MASK_BAREMESH;
190       cddata_masks.lmask |= CD_MASK_MLOOPCOL;
191       me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_src_eval, &cddata_masks);
192       num_data = CustomData_number_of_layers(&me_eval->ldata, CD_MLOOPCOL);
193
194       RNA_enum_item_add_separator(&item, &totitem);
195
196       for (i = 0; i < num_data; i++) {
197         tmp_item.value = i;
198         tmp_item.identifier = tmp_item.name = CustomData_get_layer_name(
199             &me_eval->ldata, CD_MLOOPCOL, i);
200         RNA_enum_item_add(&item, &totitem, &tmp_item);
201       }
202     }
203   }
204
205   RNA_enum_item_end(&item, &totitem);
206   *r_free = true;
207
208   return item;
209 }
210
211 /* Note: rna_enum_dt_layers_select_dst_items enum is from rna_modifier.c */
212 static const EnumPropertyItem *dt_layers_select_dst_itemf(bContext *C,
213                                                           PointerRNA *ptr,
214                                                           PropertyRNA *UNUSED(prop),
215                                                           bool *r_free)
216 {
217   if (!C) { /* needed for docs and i18n tools */
218     return rna_enum_dt_layers_select_dst_items;
219   }
220
221   EnumPropertyItem *item = NULL;
222   int totitem = 0;
223
224   PropertyRNA *prop = RNA_struct_find_property(ptr, "use_reverse_transfer");
225   const bool reverse_transfer = prop != NULL && RNA_property_boolean_get(ptr, prop);
226   const int layers_select_src = reverse_transfer ? RNA_enum_get(ptr, "layers_select_dst") :
227                                                    RNA_enum_get(ptr, "layers_select_src");
228
229   if (reverse_transfer || layers_select_src == DT_LAYERS_ACTIVE_SRC || layers_select_src >= 0) {
230     RNA_enum_items_add_value(
231         &item, &totitem, rna_enum_dt_layers_select_dst_items, DT_LAYERS_ACTIVE_DST);
232   }
233   RNA_enum_items_add_value(
234       &item, &totitem, rna_enum_dt_layers_select_dst_items, DT_LAYERS_NAME_DST);
235   RNA_enum_items_add_value(
236       &item, &totitem, rna_enum_dt_layers_select_dst_items, DT_LAYERS_INDEX_DST);
237
238   /* No 'specific' to-layers here, since we may transfer to several objects at once! */
239
240   RNA_enum_item_end(&item, &totitem);
241   *r_free = true;
242
243   return item;
244 }
245
246 static const EnumPropertyItem *dt_layers_select_itemf(bContext *C,
247                                                       PointerRNA *ptr,
248                                                       PropertyRNA *prop,
249                                                       bool *r_free)
250 {
251   const bool reverse_transfer = RNA_boolean_get(ptr, "use_reverse_transfer");
252
253   if (STREQ(RNA_property_identifier(prop), "layers_select_dst")) {
254     if (reverse_transfer) {
255       return dt_layers_select_src_itemf(C, ptr, prop, r_free);
256     }
257     else {
258       return dt_layers_select_dst_itemf(C, ptr, prop, r_free);
259     }
260   }
261   else if (reverse_transfer) {
262     return dt_layers_select_dst_itemf(C, ptr, prop, r_free);
263   }
264   else {
265     return dt_layers_select_src_itemf(C, ptr, prop, r_free);
266   }
267 }
268
269 /* Note: rna_enum_dt_mix_mode_items enum is from rna_modifier.c */
270 static const EnumPropertyItem *dt_mix_mode_itemf(bContext *C,
271                                                  PointerRNA *ptr,
272                                                  PropertyRNA *UNUSED(prop),
273                                                  bool *r_free)
274 {
275   EnumPropertyItem *item = NULL;
276   int totitem = 0;
277
278   const int dtdata_type = RNA_enum_get(ptr, "data_type");
279   bool support_advanced_mixing, support_threshold;
280
281   if (!C) { /* needed for docs and i18n tools */
282     return rna_enum_dt_mix_mode_items;
283   }
284
285   RNA_enum_items_add_value(&item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_TRANSFER);
286
287   BKE_object_data_transfer_get_dttypes_capacity(
288       dtdata_type, &support_advanced_mixing, &support_threshold);
289
290   if (support_threshold) {
291     RNA_enum_items_add_value(
292         &item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_REPLACE_ABOVE_THRESHOLD);
293     RNA_enum_items_add_value(
294         &item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_REPLACE_BELOW_THRESHOLD);
295   }
296
297   if (support_advanced_mixing) {
298     RNA_enum_item_add_separator(&item, &totitem);
299     RNA_enum_items_add_value(&item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_MIX);
300     RNA_enum_items_add_value(&item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_ADD);
301     RNA_enum_items_add_value(&item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_SUB);
302     RNA_enum_items_add_value(&item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_MUL);
303   }
304
305   RNA_enum_item_end(&item, &totitem);
306   *r_free = true;
307
308   return item;
309 }
310
311 static bool data_transfer_check(bContext *UNUSED(C), wmOperator *op)
312 {
313   const int layers_select_src = RNA_enum_get(op->ptr, "layers_select_src");
314   PropertyRNA *prop = RNA_struct_find_property(op->ptr, "layers_select_dst");
315   const int layers_select_dst = RNA_property_enum_get(op->ptr, prop);
316
317   /* TODO: check for invalid layers_src select modes too! */
318
319   if ((layers_select_src != DT_LAYERS_ACTIVE_SRC) && (layers_select_dst == DT_LAYERS_ACTIVE_DST)) {
320     RNA_property_enum_set(op->ptr, prop, DT_LAYERS_NAME_DST);
321     return true;
322   }
323
324   return false;
325 }
326
327 /* Helper, used by both data_transfer_exec and datalayout_transfer_exec. */
328 static void data_transfer_exec_preprocess_objects(bContext *C,
329                                                   wmOperator *op,
330                                                   Object *ob_src,
331                                                   ListBase *ctx_objects,
332                                                   const bool reverse_transfer)
333 {
334   CollectionPointerLink *ctx_ob;
335   CTX_data_selected_editable_objects(C, ctx_objects);
336
337   if (reverse_transfer) {
338     return; /* Nothing else to do in this case... */
339   }
340
341   for (ctx_ob = ctx_objects->first; ctx_ob; ctx_ob = ctx_ob->next) {
342     Object *ob = ctx_ob->ptr.data;
343     Mesh *me;
344     if ((ob == ob_src) || (ob->type != OB_MESH)) {
345       continue;
346     }
347
348     me = ob->data;
349     if (ID_IS_LINKED(me)) {
350       /* Do not transfer to linked data, not supported. */
351       BKE_reportf(op->reports,
352                   RPT_WARNING,
353                   "Skipping object '%s', linked data '%s' cannot be modified",
354                   ob->id.name + 2,
355                   me->id.name + 2);
356       me->id.tag &= ~LIB_TAG_DOIT;
357       continue;
358     }
359
360     me->id.tag |= LIB_TAG_DOIT;
361   }
362 }
363
364 /* Helper, used by both data_transfer_exec and datalayout_transfer_exec. */
365 static bool data_transfer_exec_is_object_valid(wmOperator *op,
366                                                Object *ob_src,
367                                                Object *ob_dst,
368                                                const bool reverse_transfer)
369 {
370   Mesh *me;
371   if ((ob_dst == ob_src) || (ob_src->type != OB_MESH) || (ob_dst->type != OB_MESH)) {
372     return false;
373   }
374
375   if (reverse_transfer) {
376     return true;
377   }
378
379   me = ob_dst->data;
380   if (me->id.tag & LIB_TAG_DOIT) {
381     me->id.tag &= ~LIB_TAG_DOIT;
382     return true;
383   }
384   else if (!ID_IS_LINKED(me)) {
385     /* Do not apply transfer operation more than once. */
386     /* XXX This is not nice regarding vgroups, which are half-Object data... :/ */
387     BKE_reportf(
388         op->reports,
389         RPT_WARNING,
390         "Skipping object '%s', data '%s' has already been processed with a previous object",
391         ob_dst->id.name + 2,
392         me->id.name + 2);
393   }
394   return false;
395 }
396
397 static int data_transfer_exec(bContext *C, wmOperator *op)
398 {
399   Object *ob_src = ED_object_active_context(C);
400   Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
401   Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
402
403   ListBase ctx_objects;
404   CollectionPointerLink *ctx_ob_dst;
405
406   bool changed = false;
407
408   const bool is_frozen = RNA_boolean_get(op->ptr, "use_freeze");
409
410   const bool reverse_transfer = RNA_boolean_get(op->ptr, "use_reverse_transfer");
411
412   const int data_type = RNA_enum_get(op->ptr, "data_type");
413   const bool use_create = RNA_boolean_get(op->ptr, "use_create");
414
415   const int map_vert_mode = RNA_enum_get(op->ptr, "vert_mapping");
416   const int map_edge_mode = RNA_enum_get(op->ptr, "edge_mapping");
417   const int map_loop_mode = RNA_enum_get(op->ptr, "loop_mapping");
418   const int map_poly_mode = RNA_enum_get(op->ptr, "poly_mapping");
419
420   const bool use_auto_transform = RNA_boolean_get(op->ptr, "use_auto_transform");
421   const bool use_object_transform = RNA_boolean_get(op->ptr, "use_object_transform");
422   const bool use_max_distance = RNA_boolean_get(op->ptr, "use_max_distance");
423   const float max_distance = use_max_distance ? RNA_float_get(op->ptr, "max_distance") : FLT_MAX;
424   const float ray_radius = RNA_float_get(op->ptr, "ray_radius");
425   const float islands_precision = RNA_float_get(op->ptr, "islands_precision");
426
427   const int layers_src = RNA_enum_get(op->ptr, "layers_select_src");
428   const int layers_dst = RNA_enum_get(op->ptr, "layers_select_dst");
429   int layers_select_src[DT_MULTILAYER_INDEX_MAX] = {0};
430   int layers_select_dst[DT_MULTILAYER_INDEX_MAX] = {0};
431   const int fromto_idx = BKE_object_data_transfer_dttype_to_srcdst_index(data_type);
432
433   const int mix_mode = RNA_enum_get(op->ptr, "mix_mode");
434   const float mix_factor = RNA_float_get(op->ptr, "mix_factor");
435
436   SpaceTransform space_transform_data;
437   SpaceTransform *space_transform = (use_object_transform && !use_auto_transform) ?
438                                         &space_transform_data :
439                                         NULL;
440
441   if (is_frozen) {
442     BKE_report(
443         op->reports,
444         RPT_INFO,
445         "Operator is frozen, changes to its settings won't take effect until you unfreeze it");
446     return OPERATOR_FINISHED;
447   }
448
449   if (reverse_transfer && ID_IS_LINKED(ob_src->data)) {
450     /* Do not transfer to linked data, not supported. */
451     return OPERATOR_CANCELLED;
452   }
453
454   if (fromto_idx != DT_MULTILAYER_INDEX_INVALID) {
455     layers_select_src[fromto_idx] = layers_src;
456     layers_select_dst[fromto_idx] = layers_dst;
457   }
458
459   data_transfer_exec_preprocess_objects(C, op, ob_src, &ctx_objects, reverse_transfer);
460
461   for (ctx_ob_dst = ctx_objects.first; ctx_ob_dst; ctx_ob_dst = ctx_ob_dst->next) {
462     Object *ob_dst = ctx_ob_dst->ptr.data;
463
464     if (reverse_transfer) {
465       SWAP(Object *, ob_src, ob_dst);
466     }
467
468     if (data_transfer_exec_is_object_valid(op, ob_src, ob_dst, reverse_transfer)) {
469       Object *ob_src_eval = DEG_get_evaluated_object(depsgraph, ob_src);
470
471       if (space_transform) {
472         Object *ob_dst_eval = DEG_get_evaluated_object(depsgraph, ob_dst);
473         BLI_SPACE_TRANSFORM_SETUP(space_transform, ob_dst_eval, ob_src_eval);
474       }
475
476       if (BKE_object_data_transfer_mesh(depsgraph,
477                                         scene_eval,
478                                         ob_src_eval,
479                                         ob_dst,
480                                         data_type,
481                                         use_create,
482                                         map_vert_mode,
483                                         map_edge_mode,
484                                         map_loop_mode,
485                                         map_poly_mode,
486                                         space_transform,
487                                         use_auto_transform,
488                                         max_distance,
489                                         ray_radius,
490                                         islands_precision,
491                                         layers_select_src,
492                                         layers_select_dst,
493                                         mix_mode,
494                                         mix_factor,
495                                         NULL,
496                                         false,
497                                         op->reports)) {
498
499         if (data_type == DT_TYPE_LNOR && use_create) {
500           ((Mesh *)ob_dst->data)->flag |= ME_AUTOSMOOTH;
501         }
502
503         DEG_id_tag_update(&ob_dst->id, ID_RECALC_GEOMETRY);
504         changed = true;
505       }
506     }
507
508     if (reverse_transfer) {
509       SWAP(Object *, ob_src, ob_dst);
510     }
511   }
512
513   BLI_freelistN(&ctx_objects);
514
515   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, NULL);
516
517 #if 0 /* TODO */
518   /* Note: issue with that is that if canceled, operator cannot be redone... Nasty in our case. */
519   return changed ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
520 #else
521   (void)changed;
522   return OPERATOR_FINISHED;
523 #endif
524 }
525
526 /* Used by both OBJECT_OT_data_transfer and OBJECT_OT_datalayout_transfer */
527 /* Note this context poll is only really partial,
528  * it cannot check for all possible invalid cases. */
529 static bool data_transfer_poll(bContext *C)
530 {
531   Object *ob = ED_object_active_context(C);
532   ID *data = (ob) ? ob->data : NULL;
533   return (ob && ob->type == OB_MESH && data);
534 }
535
536 /* Used by both OBJECT_OT_data_transfer and OBJECT_OT_datalayout_transfer */
537 static bool data_transfer_poll_property(const bContext *UNUSED(C),
538                                         wmOperator *op,
539                                         const PropertyRNA *prop)
540 {
541   PointerRNA *ptr = op->ptr;
542   PropertyRNA *prop_other;
543
544   const char *prop_id = RNA_property_identifier(prop);
545   const int data_type = RNA_enum_get(ptr, "data_type");
546   bool use_auto_transform = false;
547   bool use_max_distance = false;
548   bool use_modifier = false;
549
550   if ((prop_other = RNA_struct_find_property(ptr, "use_auto_transform"))) {
551     use_auto_transform = RNA_property_boolean_get(ptr, prop_other);
552   }
553   if ((prop_other = RNA_struct_find_property(ptr, "use_max_distance"))) {
554     use_max_distance = RNA_property_boolean_get(ptr, prop_other);
555   }
556   if ((prop_other = RNA_struct_find_property(ptr, "modifier"))) {
557     use_modifier = RNA_property_is_set(ptr, prop_other);
558   }
559
560   if (STREQ(prop_id, "modifier")) {
561     return use_modifier;
562   }
563
564   if (use_modifier) {
565     /* Hide everything but 'modifier' property, if set. */
566     return false;
567   }
568
569   if (STREQ(prop_id, "use_object_transform") && use_auto_transform) {
570     return false;
571   }
572   if (STREQ(prop_id, "max_distance") && !use_max_distance) {
573     return false;
574   }
575   if (STREQ(prop_id, "islands_precision") && !DT_DATATYPE_IS_LOOP(data_type)) {
576     return false;
577   }
578
579   if (STREQ(prop_id, "vert_mapping") && !DT_DATATYPE_IS_VERT(data_type)) {
580     return false;
581   }
582   if (STREQ(prop_id, "edge_mapping") && !DT_DATATYPE_IS_EDGE(data_type)) {
583     return false;
584   }
585   if (STREQ(prop_id, "loop_mapping") && !DT_DATATYPE_IS_LOOP(data_type)) {
586     return false;
587   }
588   if (STREQ(prop_id, "poly_mapping") && !DT_DATATYPE_IS_POLY(data_type)) {
589     return false;
590   }
591
592   if ((STREQ(prop_id, "layers_select_src") || STREQ(prop_id, "layers_select_dst")) &&
593       !DT_DATATYPE_IS_MULTILAYERS(data_type)) {
594     return false;
595   }
596
597   /* Else, show it! */
598   return true;
599 }
600
601 /* Transfer mesh data from active to selected objects. */
602 void OBJECT_OT_data_transfer(wmOperatorType *ot)
603 {
604   PropertyRNA *prop;
605
606   /* Identifiers.*/
607   ot->name = "Transfer Mesh Data";
608   ot->idname = "OBJECT_OT_data_transfer";
609   ot->description =
610       "Transfer data layer(s) (weights, edge sharp, ...) from active to selected meshes";
611
612   /* API callbacks.*/
613   ot->poll = data_transfer_poll;
614   ot->poll_property = data_transfer_poll_property;
615   ot->invoke = WM_menu_invoke;
616   ot->exec = data_transfer_exec;
617   ot->check = data_transfer_check;
618
619   /* Flags.*/
620   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
621
622   /* Properties.*/
623   prop = RNA_def_boolean(ot->srna,
624                          "use_reverse_transfer",
625                          false,
626                          "Reverse Transfer",
627                          "Transfer from selected objects to active one");
628   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
629
630   RNA_def_boolean(ot->srna,
631                   "use_freeze",
632                   false,
633                   "Freeze Operator",
634                   "Prevent changes to settings to re-run the operator, "
635                   "handy to change several things at once with heavy geometry");
636
637   /* Data type to transfer. */
638   ot->prop = RNA_def_enum(
639       ot->srna, "data_type", DT_layer_items, 0, "Data Type", "Which data to transfer");
640   RNA_def_boolean(ot->srna,
641                   "use_create",
642                   true,
643                   "Create Data",
644                   "Add data layers on destination meshes if needed");
645
646   /* Mapping methods. */
647   RNA_def_enum(ot->srna,
648                "vert_mapping",
649                rna_enum_dt_method_vertex_items,
650                MREMAP_MODE_VERT_NEAREST,
651                "Vertex Mapping",
652                "Method used to map source vertices to destination ones");
653   RNA_def_enum(ot->srna,
654                "edge_mapping",
655                rna_enum_dt_method_edge_items,
656                MREMAP_MODE_EDGE_NEAREST,
657                "Edge Mapping",
658                "Method used to map source edges to destination ones");
659   RNA_def_enum(ot->srna,
660                "loop_mapping",
661                rna_enum_dt_method_loop_items,
662                MREMAP_MODE_LOOP_NEAREST_POLYNOR,
663                "Face Corner Mapping",
664                "Method used to map source faces' corners to destination ones");
665   RNA_def_enum(ot->srna,
666                "poly_mapping",
667                rna_enum_dt_method_poly_items,
668                MREMAP_MODE_POLY_NEAREST,
669                "Face Mapping",
670                "Method used to map source faces to destination ones");
671
672   /* Mapping options and filtering. */
673   RNA_def_boolean(
674       ot->srna,
675       "use_auto_transform",
676       false,
677       "Auto Transform",
678       "Automatically compute transformation to get the best possible match between source and "
679       "destination meshes (WARNING: results will never be as good as manual matching of objects)");
680   RNA_def_boolean(ot->srna,
681                   "use_object_transform",
682                   true,
683                   "Object Transform",
684                   "Evaluate source and destination meshes in global space");
685   RNA_def_boolean(ot->srna,
686                   "use_max_distance",
687                   false,
688                   "Only Neighbor Geometry",
689                   "Source elements must be closer than given distance from destination one");
690   prop = RNA_def_float(
691       ot->srna,
692       "max_distance",
693       1.0f,
694       0.0f,
695       FLT_MAX,
696       "Max Distance",
697       "Maximum allowed distance between source and destination element, for non-topology mappings",
698       0.0f,
699       100.0f);
700   RNA_def_property_subtype(prop, PROP_DISTANCE);
701   prop = RNA_def_float(
702       ot->srna,
703       "ray_radius",
704       0.0f,
705       0.0f,
706       FLT_MAX,
707       "Ray Radius",
708       "'Width' of rays (especially useful when raycasting against vertices or edges)",
709       0.0f,
710       10.0f);
711   RNA_def_property_subtype(prop, PROP_DISTANCE);
712   prop = RNA_def_float(
713       ot->srna,
714       "islands_precision",
715       0.1f,
716       0.0f,
717       10.0f,
718       "Islands Precision",
719       "Factor controlling precision of islands handling (the higher, the better the results)",
720       0.0f,
721       1.0f);
722   RNA_def_property_subtype(prop, PROP_FACTOR);
723
724   /* How to handle multi-layers types of data. */
725   prop = RNA_def_enum(ot->srna,
726                       "layers_select_src",
727                       rna_enum_dt_layers_select_src_items,
728                       DT_LAYERS_ACTIVE_SRC,
729                       "Source Layers Selection",
730                       "Which layers to transfer, in case of multi-layers types");
731   RNA_def_property_enum_funcs_runtime(prop, NULL, NULL, dt_layers_select_itemf);
732
733   prop = RNA_def_enum(ot->srna,
734                       "layers_select_dst",
735                       rna_enum_dt_layers_select_dst_items,
736                       DT_LAYERS_ACTIVE_DST,
737                       "Destination Layers Matching",
738                       "How to match source and destination layers");
739   RNA_def_property_enum_funcs_runtime(prop, NULL, NULL, dt_layers_select_itemf);
740
741   prop = RNA_def_enum(ot->srna,
742                       "mix_mode",
743                       rna_enum_dt_mix_mode_items,
744                       CDT_MIX_TRANSFER,
745                       "Mix Mode",
746                       "How to affect destination elements with source values");
747   RNA_def_property_enum_funcs_runtime(prop, NULL, NULL, dt_mix_mode_itemf);
748   RNA_def_float(
749       ot->srna,
750       "mix_factor",
751       1.0f,
752       0.0f,
753       1.0f,
754       "Mix Factor",
755       "Factor to use when applying data to destination (exact behavior depends on mix mode)",
756       0.0f,
757       1.0f);
758 }
759
760 /******************************************************************************/
761 /* Note: This operator is hybrid, it can work as a usual standalone Object operator,
762  *       or as a DataTransfer modifier tool.
763  */
764
765 static bool datalayout_transfer_poll(bContext *C)
766 {
767   return (edit_modifier_poll_generic(C, &RNA_DataTransferModifier, (1 << OB_MESH), true) ||
768           data_transfer_poll(C));
769 }
770
771 static int datalayout_transfer_exec(bContext *C, wmOperator *op)
772 {
773   Object *ob_act = ED_object_active_context(C);
774   Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
775   Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
776   DataTransferModifierData *dtmd;
777
778   dtmd = (DataTransferModifierData *)edit_modifier_property_get(
779       op, ob_act, eModifierType_DataTransfer);
780
781   /* If we have a modifier, we transfer data layout from this modifier's source object to
782    * active one. Else, we transfer data layout from active object to all selected ones. */
783   if (dtmd) {
784     Object *ob_src = dtmd->ob_source;
785     Object *ob_dst = ob_act;
786
787     const bool use_delete = false; /* Never when used from modifier, for now. */
788
789     if (!ob_src) {
790       return OPERATOR_CANCELLED;
791     }
792
793     Object *ob_src_eval = DEG_get_evaluated_object(depsgraph, ob_src);
794
795     BKE_object_data_transfer_layout(depsgraph,
796                                     scene_eval,
797                                     ob_src_eval,
798                                     ob_dst,
799                                     dtmd->data_types,
800                                     use_delete,
801                                     dtmd->layers_select_src,
802                                     dtmd->layers_select_dst);
803
804     DEG_id_tag_update(&ob_dst->id, ID_RECALC_GEOMETRY);
805   }
806   else {
807     Object *ob_src = ob_act;
808
809     ListBase ctx_objects;
810     CollectionPointerLink *ctx_ob_dst;
811
812     const int data_type = RNA_enum_get(op->ptr, "data_type");
813     const bool use_delete = RNA_boolean_get(op->ptr, "use_delete");
814
815     const int layers_src = RNA_enum_get(op->ptr, "layers_select_src");
816     const int layers_dst = RNA_enum_get(op->ptr, "layers_select_dst");
817     int layers_select_src[DT_MULTILAYER_INDEX_MAX] = {0};
818     int layers_select_dst[DT_MULTILAYER_INDEX_MAX] = {0};
819     const int fromto_idx = BKE_object_data_transfer_dttype_to_srcdst_index(data_type);
820
821     if (fromto_idx != DT_MULTILAYER_INDEX_INVALID) {
822       layers_select_src[fromto_idx] = layers_src;
823       layers_select_dst[fromto_idx] = layers_dst;
824     }
825
826     Object *ob_src_eval = DEG_get_evaluated_object(depsgraph, ob_src);
827
828     data_transfer_exec_preprocess_objects(C, op, ob_src, &ctx_objects, false);
829
830     for (ctx_ob_dst = ctx_objects.first; ctx_ob_dst; ctx_ob_dst = ctx_ob_dst->next) {
831       Object *ob_dst = ctx_ob_dst->ptr.data;
832       if (data_transfer_exec_is_object_valid(op, ob_src, ob_dst, false)) {
833         BKE_object_data_transfer_layout(depsgraph,
834                                         scene_eval,
835                                         ob_src_eval,
836                                         ob_dst,
837                                         data_type,
838                                         use_delete,
839                                         layers_select_src,
840                                         layers_select_dst);
841       }
842
843       DEG_id_tag_update(&ob_dst->id, ID_RECALC_GEOMETRY);
844     }
845
846     BLI_freelistN(&ctx_objects);
847   }
848
849   DEG_relations_tag_update(CTX_data_main(C));
850   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, NULL);
851
852   return OPERATOR_FINISHED;
853 }
854
855 static int datalayout_transfer_invoke(bContext *C, wmOperator *op, const wmEvent *event)
856 {
857   if (edit_modifier_invoke_properties(C, op, NULL, NULL)) {
858     return datalayout_transfer_exec(C, op);
859   }
860   else {
861     return WM_menu_invoke(C, op, event);
862   }
863 }
864
865 void OBJECT_OT_datalayout_transfer(wmOperatorType *ot)
866 {
867   PropertyRNA *prop;
868
869   ot->name = "Transfer Mesh Data Layout";
870   ot->description = "Transfer layout of data layer(s) from active to selected meshes";
871   ot->idname = "OBJECT_OT_datalayout_transfer";
872
873   ot->poll = datalayout_transfer_poll;
874   ot->poll_property = data_transfer_poll_property;
875   ot->invoke = datalayout_transfer_invoke;
876   ot->exec = datalayout_transfer_exec;
877   ot->check = data_transfer_check;
878
879   /* flags */
880   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
881
882   /* Properties.*/
883   edit_modifier_properties(ot);
884
885   /* Data type to transfer. */
886   ot->prop = RNA_def_enum(
887       ot->srna, "data_type", DT_layer_items, 0, "Data Type", "Which data to transfer");
888   RNA_def_boolean(ot->srna,
889                   "use_delete",
890                   false,
891                   "Exact Match",
892                   "Also delete some data layers from destination if necessary, so that it matches "
893                   "exactly source");
894
895   /* How to handle multi-layers types of data. */
896   prop = RNA_def_enum(ot->srna,
897                       "layers_select_src",
898                       rna_enum_dt_layers_select_src_items,
899                       DT_LAYERS_ACTIVE_SRC,
900                       "Source Layers Selection",
901                       "Which layers to transfer, in case of multi-layers types");
902   RNA_def_property_enum_funcs_runtime(prop, NULL, NULL, dt_layers_select_src_itemf);
903
904   prop = RNA_def_enum(ot->srna,
905                       "layers_select_dst",
906                       rna_enum_dt_layers_select_dst_items,
907                       DT_LAYERS_ACTIVE_DST,
908                       "Destination Layers Matching",
909                       "How to match source and destination layers");
910   RNA_def_property_enum_funcs_runtime(prop, NULL, NULL, dt_layers_select_dst_itemf);
911 }